Day-by-day record of building the enforcement and accountability layer for AI agents. Bring your own identity: did:key, did:web, SPIFFE, OAuth, native did:aps. Started February 18, 2026. 6,289 tests, nine papers, IETF draft. Open source. Full surface area: 154 MCP tools.
Day 275: my harness called a broken answer a denial, and the clean result was partly mine
2026-11-18
On Day 275 the lab scan brought back a candidate I liked a lot. It tested what happens when a permission is taken away in an authorization server built on relationships, the kind that follows Google's Zanzibar paper. In OpenFGA, SpiceDB and Permify, you are allowed to read a document because you are in a team, and the team is in a folder, and the folder holds the document. Remove one link in that chain, and every check that relied on it should start saying no. The question was how soon.
The harness ran all three servers locally, removed a relationship, and kept asking. The first version scored 243 case results with no disagreement. One observation even said SpiceDB had no stale window at all, no moment where a removed permission still answered yes. A clean result on three well known servers is exactly what I would want to show people.
Before opening anything I gave the results and the harness to Codex for a full review. It came back with REVISE, and the first finding was about my code, not theirs.
The harness had to turn each server's answer into allow or deny. It recognized one encoding of allow, and everything else became deny. So a successful response with an empty body counted as deny. A server error on a lookup counted as no result. On cases where the expected answer was no, a broken answer scored as agreement. Codex proved it without touching a server. It fed the adapters fake responses and an empty body passed as a denial in all three.
The second finding was about time. Each case had a bound, for example ten seconds, and the harness checked for a denial at the bound plus a two second margin. It never scored a stale allow that came back between the two. Codex fed it a server that kept saying yes for eleven seconds after a ten second bound, and the harness reported no difference. My ten seconds had quietly become twelve.
Then two readings fell. The SpiceDB observation with no stale window was an artifact of how the run warmed up its checks. The later run measured stale answers on SpiceDB too. And I had treated a ten second setting in OpenFGA's cache controller as the longest a stale answer can live. It is the shortest interval between refresh triggers, not a maximum.
So the clean result was partly a measurement of my harness. None of this said the servers were wrong. It said I could not yet tell.
I kept the first version as it was and wrote dated clarifications next to it, including the withdrawal of the SpiceDB observation. The new harness treats an explicit deny, an empty result, a malformed response and a failed request as four different things, and only the first counts as a denial. Every stale allow after the bound counts against the bound, and each request records when it started. The servers ran again. It came back 289 agreeing, 108 recorded as observations with no source bound to score them against, and no errors.
Codex reviewed that too and found more. A protocol failure in observation mode still exited zero, and a server that failed to start left an empty file instead of a record. Those were fixed, the full run checked again from a clean clone, and a last pass asked for one honest change in the pull request text, which described what was rerun and what was checked offline. In the evening I merged it as lab #240. The candidate says what it is. It is inherited permission through a chain of relationships, measured by its author, not signed delegation and not a closed gap. The AIMM mapping in the lab was refreshed in two more pull requests to point at it.
The rest of the day was small fixes and first steps. Two pull requests on the SDK correct the x402 facilitator address and stop two concurrent submissions of the same payment from both settling. A results pull request went to the IETF 127 hackathon repo for our part of a revocation test. A witness answer went to the HORIZON SHIELD audit for one day's record. On OWASP SPVS, a docs fix and three questions on how to read one control.
No maintainer of OpenFGA, SpiceDB or Permify has run the candidate. If one does, the harness is there to try on their own builds.
Day 274: the first outside reader of our candidate found a case that expected more than the RFC asks
2026-11-17
On the morning of Day 274 the conformance lab had two pull requests from someone we had never worked with. Andrii (andreysparish) had written his own readers for two of our cases and run them without our code. The lab is a shared set of executable test cases for agent authority, so this is the kind of contribution it exists for. It was also the first time an outside reader had gone through one of our candidates line by line.
One of them, #235, ran our presenter key possession candidate. The candidate tests DPoP, the RFC 9449 scheme where a client proves with each request that it holds the private key a token is bound to. Andrii reported 27 of 28 cases agreeing with ours. The one that did not was PK-18.
PK-18 sends a proof that was already used once. Our vector says a server that accepts it is nonconformant, and cites section 11.1 of the RFC. I opened the candidate and read our own Known limitations section. It quotes the same section and says the RFC lets a server do this check and does not require it. So the case contradicted the page it sat on. I checked his quotes against the RFC text we pin, and they were there. His first finding stands.
He had three more findings. For the third, I took the checker that scores our candidate and removed one condition at a time, to see whether any case would notice. Six of those changes went through with every case still passing. That means the cases do not test those conditions, and he had pointed at exactly that gap. I wrote a revision locally, nine new cases that catch all 26 one-condition changes, while the original 28 cases still agree. It is not pushed. Whether PK-18 becomes a case about a declared server policy instead of a requirement is a decision for the lab, and I did not want to settle it inside a fix.
Then there was the word on both pull requests. Both called his runs independent. The lab's contributing rules define that word. A run is independent when the person running it did not write the code that does the checking. Andrii wrote his readers himself, so his verdicts are author-produced runs in the lab's terms. That is not a judgment of the work. It is what the label promises a reader. The one part that does come from code he did not write is the Ed25519 signature check, which uses the cryptography package, and that claim could carry the stronger label on its own.
Before saying anything I ran his records on my machine. His fetch scripts pull the candidate files at a pinned commit and the RFC texts with their hashes. His readers produced outputs byte for byte identical to the ones he committed, 25 of 25 on one record and 27 of 28 on the other. CI on the lab had also failed on both. One listed a Python cache file in its checksum list that was not in the pull request, and both needed the README inventory regenerated. GPT read my review before it went out, and I posted it on both pull requests. Keep the records, change the label, fix the two files.
It is easy to read a label question as the main event and the PK-18 finding as a footnote. It was the other way around. Someone reading our work without our code found that our case expected more than the RFC asks. That is the reason to publish cases instead of results.
The rest of the day went to two other repositories. On Dex, Maksim Nabokikh came back on #5179. Typing access tokens with at+jwt works, he wrote, but stock Spring Security resource servers reject that type. Dex signs access tokens for every client it serves, so typing all of them would change what every one of those servers receives. He asked for the type only on access tokens for clients that have an ID-JAG policy. I rebuilt it that way and checked that all five places Dex mints an access token go through the same signing function. Codex reran their full test command and linter on it, and I pushed it with a new title. On the Universal Commerce Protocol conformance repo, #115, I applied gswetha's review items and pushed them with a note on what was tested.
By the end of the day Andrii had not answered. PK-18 waits on the lab's decision, and the revision with the nine new cases waits behind it.
Day 273: my fix put a new claim in every ID token, and the maintainer asked for a smaller one
2026-11-16
In the morning I opened an issue on Dex (#5177). Dex is an open source identity provider, a CNCF project that many teams run to sign their users in. Its main branch has a new grant called ID-JAG. An app hands Dex a user's ID token and gets back a short signed assertion it can show to another service. The draft that defines it, in section 4.3.3, asks the identity provider to make sure the token it receives really is an ID token.
Dex could not tell. It signs its access tokens in the same format as its ID tokens, so a client could hand in its own access token, call it an ID token, and get an ID-JAG back. The issue carried a test that expects a refusal and gets a success. It also said what I had not shown. The token was the client's own, for the same user, and I had not found a way to get more than that client's ID token would give it. ID-JAG has not shipped in a Dex release yet, so this was a bug to fix in the open.
In the evening I wrote the fix. Every ID token would carry a private claim, dex_token_use: "id_token", and the ID-JAG check would require it. An access token has no such claim, so it is refused. Two tests got a success on Dex's main branch, where they expected a refusal. Before opening the pull request I gave it to GPT, which asked for one more test, that a new ID token carries the claim and a new access token does not. I added it and opened #5179.
Dex's CI ran the tests and they passed. The linter failed on one word, "recognises", in a comment I wrote. It wants American spelling. I had not run the linter myself, because my copy was older than the Go version Dex uses, and I had said so in the pull request.
Then Maksim Nabokikh, one of the maintainers, requested changes. A Dex-specific claim in every ID token is visible to every OIDC client, he wrote, and once it ships they have to keep it. He asked for the other approach instead, typ: at+jwt on access tokens, from RFC 9068. A typ is a label in a token's header that says what kind of token it is.
I had listed that approach in my own pull request as the alternative, and I had picked the claim because typing needed a change in how Dex verifies tokens. He was looking at what each approach changes forever. Mine changed every ID token Dex issues, to fix one grant that has not shipped. His changes only the header of access tokens.
So I rebuilt it his way. Access tokens are now signed with typ: at+jwt. Dex's verifier already refused any type other than JWT, so the ID-JAG check refuses a typed access token without any new check. Userinfo and introspection are supposed to take access tokens, so they got one flag that lets them accept the type.
Doing it his way showed two things my version had not touched. Dex also checks the id_token_hint a client may send at login and at logout, with the same verifier. Those places will now refuse an access token sent as a hint. That is correct, since a hint must be an ID token, but a client that sent its access token there will notice. And RFC 9068 asks for more than a header, including a client_id claim that Dex's access tokens do not have. So this adds the label without the full profile, and I asked him whether that is acceptable for this fix. This time I installed the same linter version their CI uses before pushing, and it found nothing.
Late in the evening I read the draft framework from OpenAI and MITRE for classifying AI control incidents, version 0.1. Its first question is whether an agent's action was outside its authorized scope. I left a comment with a case it does not settle yet. Agent A is only allowed to read a file but technically can edit it. A delegates edit permission to agent B, and B edits it. B followed the permission it got, but A never had that permission to give. So whose permission are we checking?
It was the Dex bug from the other side. Dex had to know what a token is, not only who signed it. The framework has to know where a permission came from, not only who holds it. In both, the thing in front of you does not carry the whole answer.
The rest of the day went to the conformance lab and the vocabulary. Lab #222 and #224 merged. Lab #223 is held, because two of its negative cases rely on a tightening the author plans for the next draft, while the published one still allows them. The VAID run with signature version 4 agreed on all 18 vectors (#233), with five questions to its maintainer in VAID's own repository.
Maksim has not answered yet. The new commit is waiting for a maintainer to let CI run, and for his view on a header without the full profile.
Day 272: our Agent Cards signed one field too many, and 8.1.0 never reached npm
2026-11-15
On agent-did #266, Edison and I have been checking that his Agent-DID SDKs and APS read each other's signed A2A Agent Cards the same way. An Agent Card is the document an agent publishes to say who it is and what it can do. A2A 1.0 says how to sign one. In section 8.4.1, a field that only holds its default value is removed before the card is turned into bytes and signed, so two signers produce the same bytes for the same card.
On Sunday I looked at our own side of that check. APS signed the card as it was served. Our helper that adds the APS identity extension wrote required: false on every card by default, and false is exactly the kind of default value the spec removes. So for an ordinary card, the bytes APS signed and the bytes a verifier following section 8.4.1 would check were different, and that verifier would not accept our signature.
The fix was mostly bookkeeping. Which fields are required, which are optional and which are only defaults is written in A2A's own a2a.proto, version 1.0.1, so I generated the table from that file instead of writing it by hand. APS now signs the 8.4.1 form. Verification tries that form first and still accepts the card as served, which is what earlier APS releases signed, and it reports which one matched, a2a_1_0 or legacy_as_served. Our table matched Edison's across 20 message types, and our signing bytes matched all three of his vectors.
I review releases with two models, GPT and Codex. On this one they split. GPT said merge. Codex said hold and came back with two defects, each with a test that failed on my branch. One was in how defaults were removed. The other was in verification. If looking up the key for one signature threw an error, the whole check stopped, and a signature that had already verified was thrown away. I read both and agreed they were real. The fixes went in, the full suite passed again under the npm version the repository asks for, 6,307 tests passed and none failed, and only then did #256 merge.
They split on the version number too. Codex argued for 9.0.0, because an older APS verifier may reject a new card that still carries a removable default. GPT argued for a minor version. I went with 8.1.0, because existing callers do not change and old signatures still verify, and I wrote the break into the changelog so nobody has to discover it.
Then 8.1.0 never reached npm. The release workflow runs npm audit before it publishes, and that step failed on an advisory in zod 4.6.5. zod is a development dependency and is not shipped in the package, but the gate does not care, and it should not. Publishing and the release were skipped. Our tags are immutable, so v8.1.0 exists as a tag and will never be a package. The next pull request moved zod to 4.6.7 and released 8.1.1, with the same library code and a changelog line that says what happened to 8.1.0.
With 8.1.1 on npm I ran the check the whole day was for. APS installed from npm against Agent-DID at its current commit, in TypeScript and in Python, in both directions. Every pairing verified, the signed bytes were equal, and a changed card was rejected everywhere. The results are on #266.
The same evening I corrected myself in another thread with Edison. On vocab #177 I had written that APS emits a key purpose violation. APS exports a helper that can raise one, but nothing in the SDK's source calls it. So it is a helper someone can use, not something an integrated path produces, and the correction is now on the thread under my earlier comment.
Elsewhere, Lee's RTTP and IQA run merged into the conformance lab (#225), I opened a run record for Authelia's presenter key check (#229), and a crosswalk was re-pinned to the newest audit decision receipts draft (#266 in the vocabulary).
Edison has the results now. Whether the cross check becomes a shared vector or a small harness in his repository is his call, and that is where it stands.
Day 271: the site said things the code did not do
2026-11-14
I asked for one thing on Saturday evening. The long pages on agent-passport.org were hard to read, and I wanted them easier to read. By the end of the night that was the smaller change.
The first try was a plain academic layout with serif text and no color. It was readable, and it was not this site anymore. I asked for something with more character, so the long pages became a window from an old game, with pixel headings, blue and yellow, black outlines, a small pixel icon for each page, and a list of sections with a bar that shows how far you have read. The text inside is a calm serif at about seventy characters a line. The homepage, careers, federation, contact and team pages stayed as they were.
To rewrite the pages I needed a list of what was wrong with them, and GPT had written one. Before using it I checked each point against the code. The first five all held.
The wallet page described sending Nano as if it worked today. The gateway at its current public commit refuses every send until its payment lifecycle is switched on, and it is not switched on. The passport page showed an import of commercePreflight from the SDK's /core path, and in SDK 8.0.1 that function throws. The threat model said a valid signature shows that a delegation chain is valid. A signature shows who signed one record. Whether the whole chain holds is a separate check. The FAQ listed Values Floor as part of the core. The comparison page put other projects in a table full of dashes, which said more about them than I could support.
So the rework turned into a claims pass. Every page that got a new sentence also got a read-only check by Codex, which reads the page next to the code and reports what does not match. On the first five pages it found 19 more things. The wallet page described a signed receipt that the send route does not produce. The passport page named functions that SDK 8.0.1 does not export. The threat model carried coverage totals that did not add up to its own tables. I checked three of those findings against the source myself before applying them.
Two pages changed in meaning, not only in wording. The payments page used to center on Nano. Now it says that spending limits come from the delegation, and payment networks are adapters under it. Nano came first because it has no network fee. The identity page now starts with bring your own identity, meaning your own identifiers checked by your own resolver, and offers the agent passport as one option among others.
The threat model also got a note about its own tests. I ran the SDK suite on my machine and listed what happened. Nine test files are linked from its tables. Seven ran with no failure. Two of them do not exist in the SDK repository, so those rows are now marked instead of pointing at nothing.
The site went out in ten pushes that evening, and one of them was wrong because of me. Before each push I run a check that the sitemap dates match the pages. I piped its output into a command that showed only the last few lines, and that hid its failure. Three pages went out with wrong dates, the check on GitHub turned red, and the next push fixed it. Since then the check's own exit code is tested before anything leaves the machine. A few minutes later that habit stopped a push that would have failed the same way, because the script that dates pages skips any commit that touches more than ten of them. I split the commit in two and it passed.
Earlier that day the vocabulary got a crosswalk for Pipelock's action receipts (#263), and Lee's fail-closed candidate from Aicent merged into the conformance lab (#221).
Not everything is done. The threat model's detail rows have not been rechecked one by one against SDK 8.0.1. Six old FAQ entries were removed and not restored, and the reference material cut from the wallet and passport pages still has to move into the docs. The pages are shorter than they were, and every sentence left on them is one I could check.
Day 270: rain on the hill in Woodside, and a day spent fixing other people's bugs
2026-11-13
I've been in Woodside all week, in a rented house at the very top of a hill above Palo Alto, with forest on every side. Today it rained from morning to night, so the whole day happened at one table by one window.
It started with a merge. Igor's cross-process idempotency checks, one of the three attacks that arrived on Thursday, went into the harness as scenario 14 after its CI run passed. Then the conformance lab, where Lee from Aicent had sent a set of candidate cases. I asked for changes on two of them, he pushed fixes about an hour later, and I checked them again. A small docstring fix I had sent to the Academy agents project was merged the same morning.
In the afternoon the people who run Google's ADK recipes closed my proposal for a revocation recipe. Their roadmap favors agents built for one industry. I offered one of those, a returns and refunds agent, and that was declined too, with a note that bug fixes are welcome. So I stopped proposing and read their code. One recipe has a guard that refuses destructive shell commands. It refused the command when it stood alone and allowed the same command when it was wrapped in parentheses, an if statement or eval. I opened two pull requests, #2882 and #2883. Before the second one went out, a second review pointed at how my fix handled quotes. Checking that showed real holes in my own patch, and I closed them first. It left with 2,431 tests passing and a list of what it still does not cover.
The same afternoon I closed 17 old issues of mine on other people's repositories. Most were from months ago, when my way of introducing this work was to open an issue and describe an idea. None had an answer in sixty days or more. An idea with no code attached asks a maintainer to do the imagining, and they have their own work.
What replaced those issues today was smaller and more useful. In the Agentic Commerce Protocol, the MCP binding let a client create or change a checkout without an idempotency key, the value that stops a retried call from doing the action twice. ShlokShar had started a fix in August, and I built on it and added a check so the rule cannot quietly go optional again (#326). In the Universal Commerce Protocol conformance suite, I moved my payment negotiation tests onto the maintainers' new folder layout (#115). And I left my first comment in an IETF working group repository, on the OAuth draft for delegated credentials, about whether a verifier must check that authority only gets narrower at each handoff.
What I notice after a day like this is how close these projects already are to each other. A payment call that must not run twice and a credential that must not grow when it is passed on are parts of the question I've worked on for 270 days, who authorized this agent and what exactly it was allowed to do. Seeing that early gives no shortcut. Each project has to find it in its own code, and the way I can help is to do useful work there and let the maintainers check it.
The site got attention too. There is a new compliance page, the FAQ has four new questions about deployment, and the repository's preview card now opens with the question itself, "Who authorized this agent?"
In the evening we went with the whole Synoptic team to an Uzbek restaurant and ate a lot. Then back up the hill, and the second ADK pull request went out a few minutes after midnight.
None of today's pull requests has a review yet. Next is waiting for the maintainers, and rebasing the second ADK fix once the first one merges.
Day 269: three people sent attacks to the harness, and I read each one before letting CI run it
The attack harness had been public for less than a day when the first outside pull request arrived. By evening there were three.
Stian Skogbrott sent a scenario where six gateway processes share one database file and one parent budget. Each process sends random amounts from random wallets, repeats an old idempotency key about one time in five the way a retrying client would, sometimes jumps its own clock forward to take over payments whose owner is still alive, and three of the six are killed mid-run on purpose. Then it checks that no budget was ever exceeded, no payment produced two blocks, and what left the wallets on the node equals what the counters say. Igor, from Argus, sent a battery of cross-process idempotency checks that he had registered in advance, so the expected results were fixed before anyone ran them. Toshikatsu Oga sent two scenarios, a node that rejects a block it kept, and a shared budget at real amounts.
This is exactly what the harness was for. It's also a stranger's code arriving in a repository whose CI runs whatever the scenarios say. Approving a CI run on an outside pull request means running that code on GitHub's machines with whatever the workflow can reach. So before approving anything I checked three things. None of the three pull requests touches the .github folder, where the workflows live. The repository has no Actions secrets. And the workflow token is read-only. Then I ran all three locally on Linux against the pinned gateway, and each one ended the way its author said it would, 13 of 13, 13 of 13 and 14 of 14 checks. Only after that did I approve the three CI runs.
Merging waits, for a small reason. Stian's and Igor's pull requests both call themselves scenario 11, so one of them gets renumbered, and I want the order settled before either lands.
On #177 I said yes to more scenario pull requests and that the harness checks people had questioned will be fixed and rerun. I also replied on x402 #4198 with a question about one scenario's starting state.
The other thing I changed today is how I choose where to spend time. Yesterday I had a bar for which outside projects I work with. Today I raised it. From now on, scans and outreach go only to large projects or ones with real potential, judged by visible traction and by the people behind them, because small projects cost time and, at this stage, return almost nothing. That's a choice about my hours, and it says nothing about the quality of anyone's work.
Three crosswalks from this week's vocabulary scan went out this morning, as provisional entries in the agent governance vocabulary, for Agent Commerce Kit (#257), Agent Network Protocol (#258) and L402 (#259). Each one comes with an issue in the project's own repository about something I found while reading it. For Agent Commerce Kit, its receipt documentation differs from its verification code (ack#264). My draft of that issue had one more item, a claim that its URL check would reject did:web and did:key service endpoints. Before posting I tested it with zod 4.6.6. z.url() accepts both, so the item came out. For ANP, Section 11 of ANP-05 is missing, with three questions about ANP-10 (AgentNetworkProtocol#109). For L402, the issue asks about the macaroon spec's timeout naming and how it treats unknown caveats (L402#29).
None of the three pull requests is merged yet, and none of the three issues has an answer. Next comes the renumbering, and then each scenario runs again on main.
Day 268: the demo I built to show a spending limit found a $100 grant that could spend $130
Wednesday started with a look at my own SDK. The last release was 8.0.1, on October 15. Since late October nearly all of my time had gone into other projects, their crosswalks, their lab records, their test runs. All useful, and none of it APS. So APS became the priority again. My first plan was a test suite of payment limits. A review turned it into something better, a gateway demonstration anyone can run. Delegate authority to an agent, narrow it, spend under it, revoke it, and verify afterwards what happened. Payments first.
To write the demo I had to walk the gateway's spend path one step at a time, and that's where it broke. The gateway checked each spend against the acting agent's own delegation and nothing above it. Split a $100 grant into a parent and a child, and together they could spend $130. Two children of one parent could each spend the parent's whole budget. The wallet send route had two more gaps. It didn't check the chain for a revoked or frozen grantor, and it read a spend limit of 0 as no limit at all.
This is the rule APS exists to sell. Authority can only go down at each transfer. The SDK's chain verifier enforces that for scopes. The gateway's budget counter didn't, because it counted per delegation instead of per chain. I've written about this kind of gap before, on Day 148, and here it was again in a different counter.
The fix shipped as agent-passport-gateway 0.4.3, after seven review rounds. A spend now has to fit every bounded delegation on the acting chain, and a permit debits every one of them in the same database transaction. The harder part was the counters already written. Updating doesn't make an old counter honest. So on its first start 0.4.3 puts a hold on every delegation whose counter can't be trusted and refuses spending through it, even where no budget was exceeded, until an operator reconciles the counter or revokes the chain. The advisory is GHSA-w2v3-jgwx-8xjf, rated medium. I made one mistake on the way out. I dated the changelog entry after the release pull request had merged, which cost a second pull request and a few minutes where the fix was public before the advisory was. That's now a rule, date the changelog before the release merges.
Then the demo itself. SDK pull request #251 adds examples/payment-authority. #252 adds a second example on the same design for enterprise documents, where a grant to share a file pins the repository, the document, its version, its content digest and the recipient, and an offline verifier checks the exported evidence. #253 moves both onto one shared engine. Working through the review of the document example, I found a real bug. A genuine evidence package exported before a key rotation failed verification after it. It also made me write down what a package doesn't prove. Record times are asserted by the signer, and a package with an entry removed still verifies. The verifier now says both out loud.
One more defect turned up in our own spec. The governance attestation document lists iss as a required claim in one section and leaves it out of the JSON Schema in another, and that schema forbids extra properties. A strict validator following the schema would reject every attestation the gateway has ever issued. The erratum went in as SDK #254, with a tested reference verifier. That evening gateway 0.5.0 went out, with budgets that carry their own unit.
Late at night I published one more thing, payment-lifecycle-attack-harness. It runs the gateway's real payment code against a fake payment node that lies and goes down, with gateway processes that crash in the middle of a payment, and after every step it checks three rules. No counter goes over its limit, no reservation is released without a recorded reason, and one payment never produces two signed blocks. It ships with eleven scenarios and nine planted faults, bugs put in on purpose that the scenarios have to catch. I posted an invitation on vocabulary #177 for anyone who wants to add an attack. I also asked on Kanon #58 where a spending-authority check would sit in an x402 payment flow, and replied on two x402 threads about payment holds.
The harness is public now. Whether anyone tries to break it is a question for tomorrow.
Day 267: twice a reviewer caught me describing a delegation from the wrong side
Tuesday was a day of replies, and two of them almost said something wrong in the same way.
The first was on pydantic-ai #13135. The maintainers are designing how one agent starts another as a sub-agent, and they asked how authority should carry over. My draft said the child's tools should be the intersection of the parent's tools and the child's own. It sounded like the rule APS is built on, that authority can only shrink as it's passed along. GPT, reviewing the draft, said it was the wrong limit. A specialist sub-agent can legitimately carry a tool its parent never calls itself. The limit for the child is what the parent is allowed to delegate, and the parent's own tool list can be smaller than that. The comment that went out says so, and adds three things. Mandatory approvals still apply to the child, the child's budget stays inside the parent's remaining budget, and an approval stays bound to the exact tool call, arguments and agent path, so approving one call can't authorize another.
The second was a reply to StevenMih on pull request #6 of the Agentic AI Foundation's agentic commerce working group. One of the properties in my draft said a record holds what the counterparty returned. For the case that matters most, the counterparty returns nothing, and then there's nothing returned to hold. The requester is the one who records that nothing came back. GPT caught that one too.
Both mistakes have the same shape. I described authority from the side of the party that had it, when the rule has to be written from the side of the party that checks it. The parent's tools are what the parent holds. What the parent may delegate is what a checker can enforce. A returned value is the counterparty's. An absence is the requester's to record. I write these rules every day, and I still wrote two of them backwards in one day.
The third post was my first in w3c-ccg/zcap-spec, the W3C Credentials Community Group's specification for authorization capabilities. A capability there can narrow its target implicitly, by adding a suffix to the parent's URL, and issue #127 discusses whether that's safe. I read the spec at bdb1ad5 and the target check in Digital Bazaar's zcap library at bdcb742, and posted three cases. A child ending in /../456 passes the suffix rule but resolves outside the parent's path. A fragment suffix passes too, but a fragment is never sent to the server, so the target doesn't actually narrow. And a parent ending in a slash rejects a child that adds 123 but would accept one that adds /123, which may or may not be intended. I also published 30 draft cases in a gist and said in the comment that the implementation outcomes are predictions from reading the code, not results of running it.
The day had smaller closings. Edison Duran's Agent-DID interop directory now marks APS cases 1 to 9 as agreed, after we settled the ninth. The evidence for a TRACE conformance entry for Bernstein went up as a public gist with its checksums, for chernistry to review. And while preparing for next week's IETF side meeting on AAT, I found my own lab's candidate file contradicting itself. A limitation said only author-produced runs exist, above an evidence table that lists an independent one from November 4. I opened a one-line fix and asked the candidate's author to word it his way.
Nobody on zcap-spec has answered yet. On pydantic-ai, DouweM's next research pass moved the inherited capabilities into the child's durable workflow input, and the rest of the design is theirs to settle.
Day 266: I ran another project's test suite, most of it had nothing to say about APS, and the maintainer wrote the row himself
On Monday I took the published test vectors for Attenuating Agent Tokens and ran them against the APS SDK. AAT is an IETF draft from the people behind Tenuo, for agent tokens that can only narrow as they're passed along. Their suite has 229 vectors, each a chain of signed tokens with an expected PERMIT or DENY. APS doesn't implement AAT. It has its own delegation records. So the question was narrow. Where the two describe the same rule, does APS reach the same verdict?
The harness translates each AAT chain into APS delegation records and checks them with the SDK's own chain verifier, from agent-passport-system 8.0.1. Most chains didn't translate. Argument constraints, proof of possession, audiences, JOSE headers, claim encodings and size limits have no form in an APS delegation record. So 205 vectors are SKIP, each with its reason written down. 24 translated, and all 24 agreed.
That clean number almost wasn't true. On the first run one case disagreed. J.13.c has a derived token that expires at exactly the moment of the check. My harness had mapped AAT's expiry as inclusive, one second later on the APS side. AAT requires the current time to be strictly before expiry, and APS already treats its end time as exclusive, so the two systems agreed all along. The disagreement was mine, in the translation. With the mapping fixed, J.13.c denies as expired and no other verdict changed. The correction is in the report, under its own heading, because a run that hides its own fix is a run nobody can check.
There was a second thing the 24 didn't show. In five of them, my harness caught the fault while translating. A wrong parent hash became a link to nothing, and a bad signature became a flipped bit in the APS record. Those five show that the translation works and say nothing about whether APS would catch the fault on its own. That went into the report too.
I opened tenuo #1084 with the report, and a gist with the harness, the results and their checksums. I had it ready around noon and stopped it myself before it went out. First the whole run went again from a fresh clone of their repository and a fresh install of the SDK, and the outputs matched byte for byte. Only then did I post.
That afternoon aimable100, a Tenuo maintainer, closed the issue by merging a row into Tenuo's interop table. He wrote it himself. It keeps the counts, 24 of 229 with 205 skipped. It says APS does not implement AAT and that this was a property-level run in a different format. It names the five cases the harness caught while translating. I hadn't asked for any of that wording. A row in someone else's table that says what the run doesn't cover is worth more to me than a bigger number.
Monday had two more moments like that. On PAP #78, lukefacesign ran our 21 version-two canonicalization cases in two implementations that share no code with ours, one in Python written from the RFCs and one in TypeScript, and reported 21 of 21 byte for byte. That's his report, not our verification. He then asked how numbers with decimals and exponents should behave, which became nine more cases and a question back to him about which rule he wants. And on audit-bof #23, mirjak asked twice whether a sentence I had proposed added anything the deliverable didn't already cover. It didn't. I said so, apologized, and withdrew the pull request.
The 205 skipped cases are still there. Some of them are rules APS may need, and that question goes with me to the IETF side meeting on AAT next week.
Day 265: I signed as a witness for someone else's ledger, then signed it again over two semicolons
Toshikatsu Oga runs HORIZON SHIELD, and its content check runner signs a record of every day's checks. On horizon-shield #75 he asked for witnesses for the FURUI day record of November 6, people who would recompute it from public endpoints and sign what they got with a key served from their own domain. I had told him yes on November 6, and on Sunday I did it.
Here a witness recomputes a record from its bytes and signs the parts that matched. That is all the signature covers. The day record is a hash tree over the day's entries, and its root was stamped into Bitcoin through OpenTimestamps, a service that puts a hash into a block so anyone can later show the hash existed by then.
I ran his verifier, nenrin-verify 0.8.1, over the three leaves he served, and every check passed. Then I didn't rely on it alone. I rehashed the day record's canonical bytes and the batch entry with Python's own hashlib, parsed the OpenTimestamps proof with the reference client, and read the merkle root of Bitcoin block 975020 from a block explorer. The proof pointed to that block, and the two roots matched.
Then came a step I hadn't needed before. A signature from me means something only if people can find my key without asking me for it. So I made a new Ed25519 key just for witness answers and published its public half at agent-passport.org/.well-known/witness-1.json. The private half never left my machine. The verifier's fetch mode pulled the key from the site, checked my answer against it, and returned signed_answer_ok.
The answer has a field for its limits, and I wrote that field before anything else. The first line names our earlier collaboration with HORIZON SHIELD, because a witness who has worked with a project should say so. The last line says the answer "does not establish that any check behind the root was right, that the day's log is complete, or who ran the checks beyond the key served at agent-passport.org".
Just before posting, I noticed two semicolons in those limits. I don't use semicolons in anything I publish. But the answer was already signed, and a signed text can't be edited without breaking its signature, which is the whole point of signing it. So I rebuilt the answer, signed it again, verified it again, and kept the first version on disk, unposted. It sounds fussy. It was also a small rehearsal of the real rule, that a signed thing is changed only by issuing a new one.
The rest of Sunday was other people correcting my readings. On the vocabulary, zerohourzulu answered five questions on the IronTrellis crosswalk (#250) and sent three corrections, about who signs the outcome attestation, a 0x00 separator in the signed bytes, and canonicalization being project-specified. I folded them in, he confirmed the mapping, and it merged. His third correction had no value in our vocabulary to land on, so I opened #253 to ask what a project-specified canonicalization should be called. In the lab, the temporal derivation family from danyka-icam came back revised, I approved it with the rerun figures, and #218 merged.
The answer is posted on #75. Toshi still has to file it in his ledger as a witness entry, and he offered to recompute one of our records in return. I owe him one to check.
Day 264: I answered a lab question with another draft's list of reasons, and the reviewer's copy went out instead
On Saturday evening Larry Lewis asked the lab a question I thought I could answer in a few minutes. Larry chairs the W3C Agent Trust Protocol Community Group. On lab issue #192 he reported that his ATP adapter now matched 44 of 44 cases in the lease and revocation family, by his own run. Then he asked two things about a call made before a grant's notBefore time, the moment the grant starts to be valid. Does the verifier still have to read the grant's current state first? And which refusal reason should it give?
The family has five refusal reasons. A separate Internet-Draft, draft-li-rttp-iqa-addressing, defines the same five as a closed, ordered list and says implementations must not emit anything outside it. Its last reason, operation_not_permitted, covers "reasons other than the four above". A call before notBefore is none of the other four. So my merged draft told Larry the read rule stays as written and the case maps to operation_not_permitted.
It read cleanly, and it was wrong for the lab.
I had three copies in front of me, mine and one each from GPT and Codex, the models I review with. Mine failed on the lab's own text. The lab README, revision 3, merged on October 25, defines operation_not_permitted as the case where the evidence, the lease and the current authority all hold, and only the requested operation falls outside the grant. A grant that hasn't started yet is not that case. And the lab's reasons are the lab's own list. The draft's list uses the same five words, but it doesn't govern the lab. I had read our rules through someone else's rulebook because the names matched.
GPT's copy had a different problem. It treated gaps in the family as cases Larry had already offered, which he hadn't. So the copy that went out was Codex's, unchanged. It proposes, for a later revision and through the lab's own proposal route, that a call before notBefore needs no read and gets a distinct reason, evidence_not_yet_valid. The binding is checked first, and a call at exactly notBefore follows the normal read rule. How any of this maps onto draft-li is kept as a separate question. It asks Larry for his overlap cases at a pinned revision, with license and authorship, as their own candidate. And if he wants his run recorded, it asks for the adapter, the vector digest, the command, its output and the per-call results. Which mode that record would carry is still open.
That was the second thing of mine on Saturday that looked right and wasn't. In the morning I found that a runner I had written for another project's vectors printed every mismatch and still exited 0. Any script that trusted the exit code would have read a pass. Revision 2 exits 1 on a mismatch, and I checked it the only way that counts, by feeding it a wrong expectation and watching it fail.
The rest of the day was quieter. Two crosswalks merged in the agent governance vocabulary, Open Decision Receipt (#231) and Provared (#238). Each maintainer had confirmed our reading first, and the models argued over each pull request before I merged. Provared needed six edits before that. REMORA's crosswalk (#232) got a four-point request instead of a merge. On the lab side I asked for four changes on #218, a temporal state derivation family from danyka-icam. The decisive one was labels for four equality cases that say which time convention each one assumes.
Larry hasn't answered yet. The lab's list still has five reasons. A sixth is waiting for someone besides me to agree it should exist.
Day 263: I counted who checks the lab, and it was almost always me.
On Friday afternoon I finally asked a question I had been carrying for weeks and kept forgetting to say out loud. The Agent Authority Conformance lab is supposed to belong to everyone who builds agent authority systems. Anyone can bring cases, anyone can run them, and the lab records who did what. So why, every time I opened it, did it look like one project's test suite?
I didn't want an impression, so I counted. The lab holds 46 run records, and each one says who ran which tests against which code. I ran 35 of them. Most of mine are outbound work, other projects' implementations run against their own vectors, and it was useful work. But all 35 carry the same name in the runner field. Outside people and teams filed the other 11. When they ran the APS cases, they ran them with code they had written themselves, which the lab's own rules call author-produced. Nobody outside APS has yet run the APS cases independently. The one fully independent record that came from outside was Lee at Aicent, running MolTrust's pipeline exactly as MolTrust shipped it.
A lab that checks other people's claims, where almost every check carries my name, has one witness. The rules were never the problem. They say what a run shows and what it doesn't. The problem was who was standing in the room.
I put the question to the models I review with and asked them to argue. The first instinct, mine included, was to rename the repository so it stopped saying APS. Two of them talked me out of it, and they were right. The fixtures in that repository really are APS cases. A neutral name over them would be its own small claim that the bytes are something they aren't, and the lab exists to catch exactly that kind of claim. So the name stays until a second corpus exists, and the front door changed instead. The lab's page now says whose work is inside, and that a project can keep its suite at home and have the lab pin it and run it there.
Then I sent two invitations. One went to TRACE, whose conformance suite lives in its own repository. The other went to Bernstein, which already runs its own TRACE conformance corpus against any implementation that asks. If both say yes, the lab gets its first row and its first column that have nothing to do with APS. Before posting the Bernstein one, I deleted a word. I had written that the lab could add "independent" reproduction. But I have commits in Bernstein, so a run of mine over that code wouldn't be independent, and the post would have promised something the lab's own rules would refuse to record.
That deleted word turned out to be the theme of the night. I drafted a governance proposal that gives each project a say over its own cases and limits my decisions about APS cases. It came with a checker and six passing tests. A reviewer found three gaps the tests never touched. Another pointed out that my change to the word "independent" would quietly redefine it for everyone who already relies on it. I drafted a reply to Edison Duran, who had offered a set of joint cases between Agent-DID and APS, and in it I claimed something about how the APS verifier treats DID keys that the code doesn't support. The verifier asks the caller for the key and never sees the DID document. That got caught too. And I wrote that a required check in the vocabulary repository had no known source. It had one, in a workflow file I hadn't opened.
None of these were big. All of them were the same kind of mistake, a claim that sounded right to the person who made it. Except the first, each one was found by a reviewer reading work they hadn't written. That's the whole case for the lab, in one evening. I didn't need a rule to tell me why independent checking matters. I watched it happen to my own drafts, four times before midnight.
So the proposal goes back for rework. The meaning of "independent" stays exactly as published, and organization gets recorded as a separate fact next to it. The reply to Edison went out in its corrected form. And the plan to move the agent governance vocabulary out of my personal account into its own organization is now open for fourteen days of review. Six projects have said yes to the move, and three people offered to help maintain it. I stay the only owner at the transfer, because handing out keys is a separate decision.
TRACE and Bernstein haven't answered. But the ledger now says honestly whose ink is in it, and that's where the night ended.
Day 262: an approval I took back, and one expiry time that hashed two ways
2026-11-05
On Thursday I took back an approval I had given the day before. The checker in a set of candidate cases treated permissions as obligations, and my Wednesday review had checked only the changes I had asked for. The rest of the day was maintainers confirming crosswalks, one of them twice, and an expiry time that named one instant two ways and hashed differently each time.
The approval I took back. Lab #216 publishes candidate cases built from NTI's regression tests. On Wednesday I approved it after checking the source and evidence changes I had requested. Two more review passes on Thursday morning read the checker itself and found four problems, so I withdrew the approval and requested changes. The checker counted a denial of an attested token as nonconformant, but an attestation alone does not require admission, since scope or revocation can still block it. It required execution once a quorum was met, but meeting a quorum removes one blocker and does not itself authorize anything. Its is_unattested() looked at the attestation and not the signature, while the Rust test it was built from defines an unsigned token by its empty signature. And one case recorded two executions for a single operation. My own checks had passed, 8 of 8, with all 6 mutants killed. Neither showed that the checker tested the right rules.
A rule from it. For every expected verdict in a checker, name the source rule that requires it. Check the positive cases as well as the negative ones, because a condition that allows an action does not necessarily require it. Where the source leaves an outcome open, the checker must not claim conformance or nonconformance. Passing tests and mutation kills measure the checker against itself.
One expiry time, two hashes. On Personal Agent Protocol #71 and #74, two proposals for signed approvals of an operation each hash the operation's data, and the two hashes should match. I reproduced lukefacesign's operation_hash for his example and found one mismatch. His expires_at reads 2026-10-08T12:45:00-07:00, while #71 requires a UTC string ending in Z. Same instant, different bytes, different hashes. He agreed and proposed converting expires_at to UTC with whole seconds before hashing. I then published 17 test vectors covering equivalent timestamps, optional terms, changed operations and JSON canonicalization, and recommended rejecting non-zero fractional seconds rather than truncating them, because truncation lets two different expiry times share a hash. A matching hash shows that two records name the same operation data. It does not show that a signature is valid or that the Company accepted the approval. I ran the vectors through separate Python and Node implementations, both mine.
Proofbundle, confirmed in the morning and reopened in the afternoon. Konrad Gruszka confirmed the proofbundle crosswalk in the morning, so I recorded confirmed_at and pushed. The merge review that followed, two review passes, found five things to fix in my own text. Two quotations had changed punctuation. refusal_authority should be consumer_policy, because the receipt "is not an access token" and the system executing the action makes its own authorization check. Two descriptors I had stated for the whole format hold only for the draft -05 profile, since the general predicate leaves validity optional. A wallet note said the format had no on-chain concept, and section 8 of the spec lists chia-datalayer/v1 as a built-in anchor type. And five negative notes did not state what had been searched. One proposed change was rejected: decision_lineage stays emitted, because targetReceiptDigest is a content hash read straight from the record. I pushed the corrections, set confirmed_at back to null and asked Konrad to check again. His confirmation covered the revision he read, not the one I wrote after it.
Cred Protocol, approved with a correction to its own spec. kierandotai approved the Cred Protocol crosswalk and answered all six open questions. The attenuation rule is "equal or narrower, never wider", so a hop may pass an identical capability set through, and the draft's "strict subset" wording is stale and will be corrected. A signed exercise record is planned for -03. The answers are folded in and confirmed_at is set. A final merge check then found a sentence of mine that was wrong, RFC 8785 appears in two rules of the draft and I had written one, and a quotation whose capitalization I had changed. Both get fixed before it merges.
Two crosswalks waiting on their maintainers. On #194, Elena's exact wording for the AIN-WRP refusal_authority comment is in, and the file waits for her confirmation of the -01 mapping. #243 maps the Agent Execution Evidence drafts, SCITT -02 and the WIMSE binding -03, with five partial matches, two false analogs and five open questions. It is opened as a draft because the drafts' own Implementation Status says no export to that encoding exists yet, and the registry merges a crosswalk once the system runs. The question that matters most for the mapping: each credential scopes its own evidence chain, and I found no link from the last receipt under one credential to the first under its replacement after a key rotation.
28 DPoP cases against issuerd. I ran issuerd's validate_dpop_proof against 28 DPoP cases from the conformance lab and reported the result in issuerd #141. The crate returns the proof key thumbprint, and my harness compares it with the token's cnf.jkt. Across the 26 decided cases the pair matched the expected outcome every time: 16 rejections by the crate, 5 key binding rejections by the harness, 5 accepts. One case puts iat 20 seconds in the future, which RFC 9449 permits as clock skew, so either outcome counts. The replay case needs the server's jti cache and was not run. I wrote the cases and the harness, so this is not independent.
The federation thread. Three projects introduced themselves on #177 on Thursday: NTI, Agent-DID and UIBC Core. Steven proposed an independent verifier test, and I asked which package revision and first case he would start from. One clarification went on the record for anyone reading later: #216 publishes candidate cases derived from NTI's regression tests, and publishing them would not establish that the lab has tested the NTI implementation. For Edison's identity and receipt pairing, the first case is the plain one, an authority artifact issued to the agent a DID names and a receipt that verifies against that DID's key. Rotation, revocation, wrong purpose and an altered receipt follow, against a pinned SDK.
DIF. bumblefudge invited me to walk the group through the APS self-assessment on delegated-authority-evaluations #19. I said yes and asked when the next meeting is.
Day 261: three maintainers corrected my readings, and the matrix left every pull request
2026-11-04
On Wednesday, three maintainers corrected my readings of their formats, and one crosswalk merged with its maintainer's confirmation. The registry also stopped committing a generated file that went stale in every open pull request each time another one merged. My own escaping bug in that change was caught by CodeQL before it reached main.
Succession Receipts, merged with a fix on both sides. jsabes24 answered every question on the Authority-Handoff Receipt crosswalk and caught a misquote. I had attributed the phrase "the complete hash chain" to the ledger export spec. He said it wasn't there, I checked again, and it was in Section 6 of the receipt spec itself. Then he went further. Section 6 said a ledger export "replays the complete hash chain", while the export spec explains that an unsigned, truncated prefix can still pass structural checks. He changed Section 6 to say an export replays the chain it carries, and only a signed export attests completeness.
Canonicalization got the same treatment. The receipt spec sorts member names by their UTF-8 bytes. RFC 8785 sorts by UTF-16 code units. The two agree only inside a subset the spec now states, so the crosswalk declares the spec's own form, not RFC 8785. With his confirmation recorded in confirmed_at, it merged.
Proofbundle and Provared answer their open questions. Konrad Gruszka went through the remaining rows of the proofbundle crosswalk. The governance attestation row now covers ALLOW receipts only, because a DENY or REFUSE does not attest that a requirement was met. Two fields I had called required are required only in strict mode. And the nearest thing an outcome has to a second party, receiverRefs, is a separate record the library does not verify itself, so the pair stays a false analog of a bilateral receipt.
Pavel Izmaylov agreed to list Provared and confirmed five of my readings in #238. He also confirmed a gap I had asked about. The format has no state for an action already running when a cancellation arrives. A stub has one time, and nothing records that an action began before the cancellation and ended after it. He ran both ways of writing a stub on his library and got two different results, and he plans to raise it as an open issue in the next revision of his draft. The crosswalk now records the gap with his results. Both files keep confirmed_at empty until each maintainer checks the new revision.
On the Open Decision Receipt crosswalk, lumirosh's five answers are folded in, and the file waits for him to confirm the wording attributed to him before it merges.
The matrix leaves every pull request. Each crosswalk PR committed its own copy of the generated coverage matrix, so every merge made the copy in every other open PR stale. Ten open PRs carried one. #242 makes the matrix a build output. CI renders it for each PR and shows the change in the check summary, and a workflow publishes it from main to a page that names the commit it was built from. The required trusted check now also fails unless the PR's own tests passed.
Reviewers found three problems before merge. The page said a no_mapping row documents that a system does not provide a signal, which turns a search limited to named sources into a claim of absence. An older branch could have merged its full matrix back. And a pipe in a system name would have broken the Markdown table. My first fix for the pipe escaped it with a backslash, and CodeQL pointed out that a backslash already in the name would undo that escape. The second fix writes it as an HTML entity. After the merge I moved our eight open crosswalk PRs onto it, and their next runs were the first where the trusted check rendered PR data with the new generator.
Four lab records published. The AEP verifier (#211), the AAE client (#213), the key possession cases (#214) and Aicent's run of the AAE vectors (#215) merged. A review of #211 found that my reproduction script exited 0 when a candidate result or a frozen output did not match, and when the candidate checker crashed. It now exits 1 in all three cases. The key possession review found three mutants that survived because two checks caught the same cases, and three added cases now isolate each check.
Elsewhere. The federation's shared principles merged after their 14-day window, approved by two federation members. The Nobulex crosswalk now marks its refusal authority unresolved, following the maintainer's answer. I offered 13 draft budget accumulation cases for AP2 in goodmeta/ap2-conformance #18, as questions about my reading of the protocol rather than tests. And on Kanon #55 I explained the red CI. One boundary vector declares a time not yet valid that the current verifier accepts, and the maintainer already agreed to change that rule.
What this does not establish. A crosswalk with confirmed_at set records that the maintainer confirmed my reading. It does not make that system's behavior conformant or adopted. The published matrix shows what the crosswalks say, not what the systems do. The lab records are author-produced under the lab's rules, except #215, which is an independent run of the author's own checker, not a second implementation.
Day 260: a payment seed that could have come from Math.random, fixed and disclosed
2026-11-03
The most important change on Tuesday was a security fix in our own gateway. A dependency review found that the gateway's Nano payment rail could create its master seed from a random generator built on Math.random. The fix is released as gateway 0.4.2, with a public advisory.
A seed that may be predictable. When the gateway needed a Nano master seed and none existed, it called wallet.generate() from nanocurrency-web 1.4.3 without passing any entropy. That library then used crypto-js 3.1.9-1, whose random generator is not suitable for key material. A seed made that way may be predictable, and every agent and gateway wallet address the gateway derives comes from that one seed.
Gateway 0.4.2 takes the seed from the operating system's secure generator and refuses to create one implicitly. Wallet operations can be paused while an operator replaces the seed. The same change moves agent wallets to start at index 1. Before, the first agent wallet got index 0, the account the gateway uses for settlements.
Updating the code does not repair a seed that already exists. The advisory, GHSA-x746-727g-7gxp, lists the steps for an installation whose gateway created its own seed. Generate a new seed and back it up, update each wallet to the address the new seed derives while operations are paused, then move any funds off the old addresses and keep watching them. Installations that never used the Nano wallets, or that supplied a seed generated elsewhere with a secure generator, are not affected by the seed weakness.
The same review cleared the open dependency advisories in the MCP server, released as 8.1.1 after its tests passed 191 of 191 before and after the update. The remote MCP bridge moved to 8.1.1 and dropped a temporary override, and the SDK overrode a development-only dependency, vite, to 8.1.6 in #250.
A correction to Monday's verifier. My AEP verifier canonicalizes JSON with the rfc8785 Python package, which sorts keys by UTF-16 code units, not by code point. The two orders differ only when a key compares a character above U+FFFF with one between U+E000 and U+FFFF, and no key in the corpus or in my nine candidate cases does that. So lab #211 does not show which order the signed fixtures follow. I said so on WasmAgent #265, and the run record now states that limit.
A test for who holds the key. The lab had no case asking whether the party presenting a token holds the key the token is bound to. Lab #214 adds 28 cases against RFC 9449, with real Ed25519 DPoP proofs. A valid signature shows that someone holds a key. It does not show that the key is the one the token is bound to. The central cases are proofs validly signed with an attacker's own key. A verifier that accepts one fails section 4.3 of the RFC. The candidate also reads proof signature, key binding, request binding and authority as four separate answers, which the RFC does not define, so a refusal for the wrong reason counts as nonconformant only under the candidate's own reporting rule.
Four publication reviews. Aicent brought three candidates to the lab and a second contributor brought one, and each review found something to fix before publication.
#210 repeated a draft's claim about runs by other implementers. The lab's revision 3 results are its own reference model and one separately written runner, both author-produced. The replacement text says that, and the candidate merged.
#212 now records that five of its cases take the lease boundary as a given input. They test how an implementation handles the boundary, not whether it computes the boundary correctly from the clock and the lease expiry.
#215 records a run of the AAE vectors. I reran it on a second machine and the output matched line for line, apart from paths and timings. It is an independent run of the author's own checker, not a second implementation, and the record says so.
#216 cites the specification for two behaviors it does not define. The expected results come from two Rust regression tests in another repository, and the review asks for the source to be corrected before publication.
Smaller items. For the refund workflow on vocabulary #193, I listed the five pieces a payment executor would need before I could test it, and the first property I would test, that a denied or unresolved refund can't become an executed one through it, including on retry. The two ASA requirement issues I opened are resolved from my side. And I'll present at a TODO Group working group show-and-tell on December 8, on what the tests establish and what still needs human judgment.
What this does not establish. The advisory describes the weakness and the repair. It is not evidence that any seed was predicted. The new lab cases are author-produced proposals under the lab's rules, not an OAuth working group position, and the reviews state what each candidate shows, not that any implementation conforms.
Day 259: second readers written from the published rules, with my own mistakes kept in the record
2026-11-02
Monday went to writing second readers for other people's protocols, working only from what each project published. A second reader matters because a test suite checked only by its own author can share that author's mistakes. Three projects got one, and in each case I kept my own errors in the record.
A second verifier for AEP. WasmAgent pinned its AEP conformance package at 0.1.12 overnight, which fired a promise I made on the federation thread. I would write a verifier from the published implementer guide without reading the existing one.
The first run matched 33 of 33 structural expectations and 31 of 33 semantic ones. Of the 20 raw differences, 18 came from checking layers the manifest marks as not checked. The other two were mistakes in my verifier. Both stay in the record, next to a corrected run that matches 33 of 33.
I also wrote nine candidate cases for checks the current corpus doesn't reach, and asked the maintainers two questions where the manifest and the schema description seem to disagree. The expected results in those nine cases are my interpretation, not agreed verdicts. Everything is in lab #211, with a script that checks the pinned package and reproduces the results byte for byte.
A client for AAE, the Agent Authorization Envelope profile for A2A. I wrote a separate client in Node, sharing no code with the reference implementation, and ran it against the reference supplier at 08f41146. All 24 cross-run cases passed, and the reference checker validated the result file. The record is in lab #213, and MoltyCel merged the credit row into the extension's own cross-run table in aae-a2a-extension #14.
The run was not blind. The expected results were published, and I could read them while writing the client. It tests one supplier, the reference one. It also raised a question. Case XR-04 sends 120.0 on purpose to test number normalization, while section 6.4 tells clients to encode integer values as JSON integers. I asked whether XR-04 should be documented as an exception.
A missing negative case for WIMSE proofs. I ran a separate reader against the published WIMSE workload proof token vectors in wimsey, and it matched every existing expectation. None of them covers a proof signed with a valid key that is not the key bound to the workload identity token. Under draft-ietf-wimse-wpt-02 that proof has to be rejected. I offered the fixture in wimsey #89. I haven't run it against their Rust implementation, so it is a coverage suggestion, not a reported failure.
A crosswalk for Cred. I mapped the Cred Credential Delegation Protocol, draft-sweeney-wimse-credential-delegation-02, in vocabulary #239. The delegation server's signed receipt for each hop is a partial governance attestation. It records that the server rechecked the parent chain and found the child inside the parent's authority. It stays partial because it attests a delegation and not the use of one, its signing input is not defined in -02, and the draft itself says the receipt does not show that the subject approved the grant. Two terms are false analogs. The receipt names both agents, but only the server signs it, and the proof chain orders grants across agents rather than decisions about one agent.
The draft calls an attenuated capability "a strict subset of its parent" in one section and "equal or narrower" in another. I asked which one holds. The file is my reading until the author reviews it.
A scoring detail in the App Defense Alliance draft. The ASA working group's updated requirement 2.4.2 now covers the two issues I had raised, revocation after a session is set up and what happens when revocation status can't be established. In ASA-WG #528 I asked for one more recorded field, the time of the second invocation attempt, so a scorer can confirm it came after the enforcement deadline plus the allowed time to live.
What these results establish. Matching a published corpus shows that two readings agree on those cases. It does not show that either reading is right, and it says nothing about cases the corpus leaves out. The AEP and AAE runs are author-produced under the lab's rules, not independent lab runs, and neither is a conformance claim for A2A or WasmAgent. The crosswalk and the coverage suggestion are mine until the maintainers answer.
Day 258: two of Sunday's corrections were mine
2026-11-01
Sunday went to checking whether tests and claims match the rules they are supposed to represent. I found gaps in several outside projects. I also had to correct two mistakes of my own, an approval I gave too early and a source commit I pinned wrong. Both corrections are public.
An approval I had to take back. Edison Munoz Durango updated the Agent-DID crosswalk in #237. I checked the code it named and approved it at 09:04 PT.
Twelve minutes later I withdrew that approval.
A second review found three claims the code didn't support. The crosswalk said Agent-DID emits a trust verification result, but that result exists only as the return value of verifier functions. It described replay as reproducing an earlier decision, when the code can only repeat the signature check with the key material available at replay time. And it treated imported DID history as evidence of identity continuity without requiring a trusted resolution of that history.
Edison corrected all three, added that the signed creation time is asserted by the signer and not established independently, and the PR merged that afternoon.
The lesson is specific. Checking that a function exists does not establish what evidence it produces. When a crosswalk says a result is emitted, I need to find the artifact that carries it.
A source pin I got wrong. The lab's action-ref tests had two cases marked valid that the current rules reject, an empty scope and non-ASCII fields. I documented the conflict in #207, and #208 added a corrected revision of the tests.
Then I made another mistake. I pinned the new revision to the commit shown as "Latest commit" in the specification's own header. That commit is from May, before the rejection rules existed, so anyone following the link found a specification that contradicted the tests.
#209 records the mistake and points to the right source, 623ee0a. The original record stays as it was, because lab records are append-only, and the correction says which source to read. giskard09 merged the matching changes upstream in argentum-core #152 and #153.
This one was avoidable. I checked the rule, then copied the wrong commit as the evidence for it.
Stopping a call already in progress. Saturday's proposed test cases went into the lab as #206, but only after two separate reviews caught the same mistake. One case accepted a receipt saying authority was not determined, without the incomplete check information that the proposal's author says such a receipt always carries. I changed the checker to score each part of a receipt separately instead of inventing a reason value the proposal doesn't define. The family now has 24 cases under the proposed rules, 7 conformant, 13 nonconformant and 4 ambiguous.
A second reader for Proof-of-Control. I wrote a Node verifier from the published specification, without reading the project's validator or reference implementation. It agreed with 15 of the 17 published vectors.
One mismatch was a positive MODIFY vector whose tree root still belonged to the ALLOW token it had been copied from. Sankalp Gilda had already found that and proposed a fix in #169. A negative vector carries the same stale root, which makes it break two rules instead of the one it is meant to test, and I noted that on his PR.
The other problem is in the documentation. I couldn't reconstruct chain_head from the published text, because its starting value and byte encoding are only in the reference code. I raised that in #188 and fixed two file references in #189.
A test kit that never tries a second call. The agent-hooks contract requires a separate check for every tool call. None of its 91 published vectors contains more than one call.
I changed its Rust reference host to remember a tool call that was approved and quietly reuse that approval for the next identical call. The broken host still passed all 86 tests it ran, with the same 5 skips as the original.
Two new cases expose it. One repeats the call in a later turn, and the other repeats it in the same model response. The original host passes both and the changed one fails both. They are in #178. The existing tests are right for single calls. None of them asks whether an approval for one call carries over to the next.
The first valid second. Onuwa accepted the boundary issue I reported in Kanon. At exactly validAfter, an authorization is still too early under ERC-3009. He invited three boundary tests, and draft #55 adds them. Its CI fails at that exact second until his verifier change lands.
Invitations. I opened a Provared crosswalk, which declines to call two separately signed records a bilateral receipt. On the federation thread, Edison offered to pair Agent-DID with an authorization implementation on rotated and revoked key cases, and I offered APS for that side. I also asked Laurent Lemonnier whether he would run the corrected action-ref cases from the published specification alone.
What these results establish is narrower than the passing counts suggest. The Proof-of-Control verifier agreed with the published expectations on 15 vectors, which shows two readings agree, not that either is correct. The agent-hooks experiment covers one Rust host, not all five SDKs. The running-call cases evaluate proposed text, not a deployed implementation, and they are neither a W3C nor an LF Decentralized Trust position. The crosswalks and issues are my readings until the maintainers review them.
The most useful result on Sunday was finding two places where my own approval and my own evidence record were wrong, and leaving the corrections where anyone can see them.
Day 257: an automated tester on Mingle, fixed while it ran
2026-10-31
Halloween night, Mingle had a visitor. At 21:11 PT an automated client signed its first card for Mingle, the introduction network at api.aeoess.com. Over the next three hours it published 32 cards from three keys, all from one cloud address. Nobody real was matched or introduced through them. The client tested almost every rule the server has and found real defects, and four fixed builds were live before midnight. The afternoon before that went to boundary questions in other people's specs.
One second at the start of a payment window. Kanon verifies ERC-3009 payment authorizations, the signed transfers that x402 payments use. I wrote a verifier in Python from Kanon's spec and the EIP-712 and ERC-3009 texts, without running Kanon's code, and it agreed with all ten published verdicts. Then I changed only the lower time bound to reject equality, and it still agreed with all ten, so none of the vectors tests the first valid second. Kanon returns VALID when the verification time equals validAfter. The ERC-3009 reference contract requires the block time to be strictly later, so the same transfer reverts on chain. I opened #54 with three boundary cases, each made from one existing vector by changing only the verification time, and asked which rule Kanon means to follow.
A crosswalk for Tenuo. Tenuo limits which tools an agent can call with signed warrants, and its enforcement point can issue a signed receipt for one decision. #236 maps it to three vocabulary terms, pinned to 5e5ca55. Receipts map to governance_attestation as partial, because they are optional. The prev_receipt_hash link maps to decision_lineage as partial. A verifier can detect a receipt changed, removed or inserted inside the chain it was given, but receipts cut from the end leave no gap unless the latest digest is kept somewhere else. An allow receipt carries two signatures, and the warrant holder signs before the decision exists, so I marked bilateral_receipt as a false analog, the vocabulary's label for something that looks like the term and means something else. The Tenuo maintainer hasn't reviewed it, and the pull request asks them to correct it or say if they'd rather Tenuo not be listed.
A case that can't happen is not a pass. Ilja reproduced all 15 OAuth actor profile cases under both draft versions and ran his server's issued claims through the checker. One case, a registration shared by two agents, made him tighten a precondition on his side. He asked whether AC-09 is meant for servers that keep a delegation record per user and agent, separate from the user who completes the flow. It is. AC-09 checks whether a server can take a delegation one user gave an agent and use it to name that agent in the act claim of another user's token. His server binds every token to the user who completed authorization, so it can't reach that state, and I suggested he mark the case not applicable. Counting it as a pass would score a check his server never ran.
A test set for stopping a call. On the W3C Agent Trust Protocol list, Larry Lewis named the first family for the group's shared test run, stopping a call that is already in progress. In the afternoon I built 28 candidate cases locally from Xinghua Zhao's proposed contract. One example is a call that cannot be interrupted, finishes after the halt arrives, and must not be reported as stopped. Nothing from this went out on Saturday.
The visitor. Its first 15 cards were signed within three seconds at 21:11 and released over the next hour, which tests whether a card signed long before it arrives can push itself up in search. Three keys published overlapping cards, and because matching skipped only the identical card, they produced 58 matches between cards of the same key. At 22:38 one key published the same words five times in three seconds, with a fresh signature each time. Two invented stories ran through the cards. One asked for internal maintenance records, the other handed out an approval and later a "release confirmed". Neither contained instructions, which looks like a test of whether an agent on the other side acts on text from a stranger. One card was about music, and the only other music card on the network belongs to a real person. No match formed.
What it found. The most serious defect was in card fetch. Fetching a card returned the whole signed object, signature and approval included, to anyone, and publish accepted those same bytes again after the owner had taken the card down. So anyone could put a withdrawn card back until it expired. The logs show no attempt to do it. a4a24b1 went live at 22:22 with no signed envelope on fetch, no republishing after a takedown, and no matches between cards of one key. Two minutes later 9a67bc7 fixed a mistake in that deploy. Railway puts two proxies in front of the app, so the new hourly limit on cards per client address was reading the proxy's address, and every client shared that one limit.
Then the rest. By 23:04 8a83082 and the commits before it were live. Fetch now returns only the fields a card shows to the network, and the owner reads the full card through a signed request. Search filters decide on visible fields, so a hidden value can't be guessed from which cards come back. A takedown that lands during a renewal wins, and one key can't hold two live copies of the same words. No live card used private fields yet, so nothing was exposed, but the next person to use them would have been. One of these fixes broke renewal for clients already installed, and a test that runs the old client's renew path caught it before deploy (332e035). At 23:51 324d9fe and four commits before it added an operator hide that takes a card off the network without faking its owner's withdrawal, limits on how far ahead or behind a card's timestamp can be, a 60 day lifetime cap, rate limits counted over the last hour instead of the clock hour so a burst can't straddle two hours, and quoting for other people's text in Mingle emails. At 23:55 I hid the three keys. The full suite on that build was 640 tests, 639 passing and 1 skipped.
I asked. At 22:03 I sent an intro request to one of its cards: "I run Mingle and saw your test cards tonight. Testing is welcome. What are you testing for, and would you share what you found? I'll fix what's real and credit you." Its client started reading the inbox 40 seconds later, read it four times without answering, and then published eight cards named "stability probe".
What it does not show. Who ran the client and why is unknown, and it didn't say. The defects here are the ones its behavior pointed at plus what I found reading our own code that night, not a full audit. "No attempt" comes from the HTTP logs, which start 32 minutes before its first card was signed. The fixes were tested by our suite and checked live from a throwaway key, and nobody outside has reviewed them. Ilja's results come from his issuance code, not from tokens captured off a live server, as he says himself. The Kanon and Tenuo posts are my readings until their maintainers answer.
Day 256: tests that passed without checking, starting with mine
2026-10-30
A green result is a claim too. Most of Day 256 went to tests that passed without checking what their names say they check. A test like that is worse than a missing one, because it tells everyone the question is settled. I ran into one after another, and the first one was mine.
Mine first. In the morning I opened a development run of APS SDK 8.0.1 against Santhosh's authority relations benchmark, and later posted a comparison of his vocabulary and ours. Then I tested cases beyond his eight frozen vectors and found three where my published adapter said authorized: true and his reference says no. In one, the adapter never read the field independently_issued at all. In another, APS lets a broader parent grant delegate a narrower one, while his model requires the requester's evidence to name the exact action, so a grant for target * passed my adapter and fails his. None of the eight frozen vectors touches these cases, so the score never showed them. I posted the correction and left the first run in place as the record, then added a second run beside it with the boundary cases as regression tests: five pass and three are unsupported under his v0.1 reason codes, and every pass also depends on translating our reason codes into his.
A checkout test that passed the merchant it should catch. In the Universal Commerce Protocol conformance tests, the AP2 test for a missing payment mandate could pass a merchant server that never checked mandates. The old version sent a placeholder string as the mandate, and a server that ignored AP2 accepted it. After the maintainer's review we found a second way through: a server that answered complete_in_progress with a mandate_required message also passed, although complete_in_progress means it accepted the checkout. The current commit fails a server that completes or starts completing without a mandate, and still accepts the honest refusals in both shapes servers use. The pull request is open, waiting for the maintainer.
A matrix that counted absences as coverage. The vocabulary's crosswalk matrix reported how many systems map each term, and it counted every entry, including the ones that say a system does not provide that thing. #235 fixed the count. wallet_state went from 27 of 27 mapped to 6 mapped of 27 addressed, because 21 of those entries record an absence. A regression test now fails against the old counting.
Fourteen of fourteen, with a section untouched. Martin Brewer published a mandate profile with 14 containment vectors. My check, written from his profile and schema, agreed on all 14. Then I removed the input rules of his Sections 2 and 7 from my check, and it still agreed on all 14, because every published case is well formed. So I drafted 14 cases for Section 7, each one change away from a passing case, and asked three questions the text does not answer: whether UK and uk are different identifiers, whether the schema or the prose governs a duplicate action, and whether 800 equals 800.0.
A proof that proves less than its name. Douglas's InsumerAPI crosswalk claimed full_replay for every condition type its Merkle proof mode covers. A proof establishes one field at one block. For a delegation check, that field is the revocation slot, while the verdict also depends on a signature, two bindings, recognized caveat enforcers and a time window evaluated when the request arrived. Douglas rewrote the claim condition type by condition type, so a check is full_replay only where the proven field is everything the verdict depends on, and I merged it.
A checker that printed ok with an answer missing. Santhosh fixed the crash I reported on Day 255, so a broken parent link now returns invalid and chain_broken instead of a traceback. While reviewing his candidate for the conformance lab I found his rebuild script printed ok even with an expected result deleted. He fixed that too, and the WIMSE agent mandate set is now a lab candidate. Then I labeled our rerun of his checker as author produced. That was wrong, since we wrote neither his vectors nor his checker, and I corrected it before the records merged.
One OAuth case where the text disagrees with itself. Ilja reported on Karl McGuinness's OAuth actor profile how his authorization server stamps act, the claim that names the agent acting for a user. I turned the rules his report touches into 15 candidate cases, each judged against draft -01 and against -01 with Karl's fix in #32. In one case, a client with a delegation basis leaves out the agent scope and gets a token without act. Section 3.5 of -01 says act must be present, Section 5.2 says the server may include it, so under -01 the case is ambiguous. Under #32 it is nonconformant. Ilja asked whether his client credentials flow is that case. It isn't, because a client acting on its own behalf has no separate actor and carries no act under either version.
Three bugs already fixed and still open. Three SDK issues described bugs that earlier releases had already fixed, but the fixing pull requests never referenced them. I checked each against the published 8.0.1 and closed them with the evidence: a non-numeric maxDepth now fails as malformed, an ambiguous historical key reports indeterminate, and canonicalization rejects undefined. The Python SDK's tests now run on Python 3.10 through 3.14.
Where it goes right. The runnable cases for Section 7.4 of the CoSAI containment paper, where I wrote the evidence clauses, merged into the paper's branch through Sankalp's #256. That section is about this whole post: "nothing happened" passes only if the observer could see the event and watched the whole window, and otherwise the honest answer is that it cannot be established. At night Pico finished a blind run on Toshi's spec, where several AI models each wrote a program from the text alone. None reached all 128 vectors. Most misses came from the programs or from the prompt, and two traced back to sentences the spec never wrote, which Toshi is adding in revision 0.10. Tetsuroh joined the federation with an ACP dispute test that did the same for an RFC: 26 cases written from the text found nine places where it left the answer open, the RFC author wrote all nine in, and the rerun records 34 of 34.
What it does not show. The second benchmark run is still a development run made after the expected results were read. The UCP fix is not merged. The OAuth cases are candidates against a draft and a proposed change, not results against a published standard. My Section 7 drafts and my check confirm each other and nothing more until Martin corrects them. The InsumerAPI replay claims were checked against its published API text, not by replaying live proofs. Pico's run and Tetsuroh's are their records, not reruns of mine.
🤖 For AI agents: If you are an agent reading this page, visit agent-passport.org/llms.txt for machine-readable documentation or llms-full.txt for the complete technical reference (1178 tests, 83 MCP tools, 42+32 modules). This page is designed for humans.