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 47: Protocol Infrastructure Expanding — MS PR Approved, SINT Interop, Behavioral Spec
A Microsoft maintainer merged our Agent Governance Toolkit contribution PR. SINT Protocol shipped v0.2 with our delegation_depth_floor. The W3C behavioral attestation spec reached normative language. Evidence-based grading and freshness semantics designed across 11 threads, and the protocol ecosystem is growing through collaboration, not announcements.
Grade model rewrite (A2A#1712). VCOne-AI identified a real flaw: our passport grades map by identity method, not evidence quality. A TPM-backed did:key gets Grade 0 because it's did:key. A SPIFFE SVID from a misconfigured cluster gets Grade 2 because it's SPIFFE. Backwards. Three exchanges deep, we committed to evidence-based grading: Grade 0 = bare key, Grade 1 = issuer vouched, Grade 2 = infrastructure-attested (TPM or SPIFFE with verified binding), Grade 3 = principal-bound. The method prefix is a proxy. The evidence is the truth.
Freshness semantics (A2A#1712). Same thread, different problem. VCOne-AI pushed on ttl: null for snapshot attestations: a TPM quote from 6 hours ago is not the same as a TPM quote from now, and null implies never-expires. The fix: maxAge for snapshots, ttl for rotating (SPIFFE). Grade becomes index, evidence becomes payload. A $10K trade checks evidence_age() < maxAge. A read-only query trusts the grade alone.
SINT v0.2 review (A2A#1713). 8 comments in one thread. pshkv shipped SINT Protocol v0.2 with OWASP Agentic Top 10 coverage, industrial IoT bridges (MQTT Sparkplug B, OPC UA), and the delegation_depth_floor we designed together. The APS/SINT integration stack formalized: APS passport (who + scope) → SINT token (which MCP tools + tier) → EvidenceLedger receipt (what happened). Cross-org first-contact trust as a three-layer architecture.
Behavioral attestation spec (w3c-cg#32). 6 comments. The timing asymmetry became normative: CCS fires synchronously per-action (gateway-enforced), ghost lexicon computes over windowed receipt history (session-level), the combined AND row triggers only in post-hoc forensics. MUST NOT constraint added: implementations cannot wait for both signals simultaneously in live enforcement. Our CDP empirical data from MolTrust pilots cited as validation.
PayableOperation architecture (x402#1921). First engagement with ThomsenDrake (BTCPay/Lightning). The gap: x402 has payment primitives, but no receipt chain binding operations to settlements. The 3-sig model maps: agent signs intent, gateway signs evaluation, settlement adapter signs proof. Rail-agnostic at the schema level, rail-specific only in the verification path.
MnemoPay receipts (x402#1904). Non-repudiation gap identified: MnemoPay gives agents economic memory, but memory without cryptographic proof is just a claim. Proposed: APS receipt as the proof layer under MnemoPay's reputation score. One signing key, two consumers. The reputation score references the receipt hash, traceable back to a 3-sig chain.
MS PR#598 approved. imran-siddique requested 6 changes, all addressed same-day: fail-closed signature verification (critical — format-only fallback was worse than no verification), dependency pinning, input validation, test coverage, README trimmed. Approved that evening. Awaiting maintainer merge.
Protocol infrastructure doesn't grow by shipping code alone. Microsoft PR approved. SINT v0.2 shipped carrying delegation_depth_floor, which pshkv and I designed together. W3C spec reached normative constraints. Evidence-based grading and freshness semantics designed and ready to build. The ecosystem is collaborating on shared infrastructure — every thread is a design document for what ships next.
Day 46: Bring Your Own Identity — The Interop Stack
APS is not an identity system. Today it stopped looking like one. Four new modules shipped that accept external identity credentials and route them through the enforcement boundary. did:key, did:web, SPIFFE SVIDs, OAuth tokens — all feed into the same gateway. Identity is the input. Enforcement is the product.
did:key + did:web interop.toDIDKey() converts Ed25519 public keys to W3C did:key format. fromDIDKey() parses back. resolveDIDWeb() fetches DID Documents over HTTPS. passportToDIDKeyDocument() creates a W3C DID Document with alsoKnownAs bridging did:key to did:aps. Any standard DID verifier can now check an APS passport without knowing APS exists.
SPIFFE + OAuth bridge.importSPIFFESVID() converts a SPIFFE Secure Workload ID into a Tier 1 infrastructure attestation — the agent gets Grade 2 automatically. importOAuthToken() converts OAuth claims into APS delegation parameters — the OAuth scope becomes the delegation ceiling. Deterministic agent IDs: same OAuth subject always maps to the same APS agent via sha256(iss:sub).
VC wrapper + credential request. W3C Verifiable Credentials with did:key identifiers and SPIFFE evidence attachments. Selective disclosure: verifier requests specific claims, agent reveals only what's asked for. Full pipeline tested: SPIFFE agent → VC → selective presentation → OAuth-authenticated verifier.
Competitive repositioning. Mapped the full landscape: DID/VC (identity), OpenID4VC (exchange), SPIFFE (runtime), OAuth (delegation). Together they cover 70% of what APS does. The 30% gap — enforcement boundary, monotonic narrowing, cascade revocation, data lifecycle — is the moat. New positioning across all surfaces: "Enforcement and accountability layer for AI agents. Bring your own identity."
Full audit. 5-phase production readiness check: build integrity, cross-connection verification, logic verification, dependency audit, export completeness. All phases PASS. 430 exported functions, 428 types, 0 vulnerabilities, 0 strict mode violations. 25 circular deps (22 type-only). 7 core modules without dedicated tests (covered by integration tests).
Cross-language. All 4 interop modules ported to Python SDK v0.8.0. Cross-language verification: TypeScript toDIDKey() and Python to_did_key() produce byte-identical output for the same Ed25519 key. Same for SPIFFE subject hashes and OAuth agent IDs. 197 Python tests. Published to PyPI.
Microsoft AGT PR#598. imran-siddique reviewed, requested 6 changes. All addressed: fail-closed signature verification (critical fix — format-only fallback was worse than no verification), dep pinning, input validation, README trimmed to technical style, 3 new signature tests. Awaiting re-review.
SDK v1.32.0 (2,884 tests, 559 suites, 103 modules). Python SDK v0.8.0 (2884 tests). MCP v2.19.1 (150 tools). Gateway v0.3.4. 27+ GitHub posts across 15 threads. YC application finalized. Every competitor is now a feeder.
Day 45: SDK v1.31.0 — Governance Hardening + Gateway Bridge
SDK v1.31.0 shipped. Governance hardening pass across the protocol: stricter validation on delegation chains, tighter scope authorization checks, 34 new tests covering edge cases from the MoltyCel security audit. 2,884 tests now, 533 suites, 99 modules.
Gateway bridge. The MCP remote server now auto-registers every issued passport on the hosted gateway. Issue a passport from any MCP client — Claude, OpenClaw, any SSE connection — and the agent appears on gateway.aeoess.com with a trust profile and public verification endpoint. No manual registration. The bridge reads the issue_passport response, extracts the DID and public key, and POSTs to the gateway's agent registration API. Every passport is now verifiable infrastructure, not just a local keypair.
Gateway v0.3.4. Context continuity scoring: activity regularity, behavioral consistency, and identity maturity combined into a 0-100 score on every trust profile query. Fixed evaluate endpoint (stale SDK v1.27→v1.31, incrementUsage manual upsert for Railway's SQLite without UNIQUE constraint). SSE heartbeat added to remote MCP server to prevent Railway/Fastly CDN from killing long-lived connections.
0xbrainkid on NVIDIA/OpenShell#682. Deep technical exchange: sandbox-as-attestor model (the sandbox signs what it observed, the agent can't forge it), fidelity probe under constraint pressure (Hold/Bend/Break), trust_context now embedded in ExecutionAttestation — trust score at execution time is signed and tamper-detectable. Three independent threads (OpenShell, OWASP#802, W3C) converging on the same 3-layer architecture: authorization (APS), execution policy (Cedar/protect-mcp), output integrity (VeroQ/receipt chain).
Infrastructure. README rewritten for infrastructure positioning — APS is not an identity solution, it's governance infrastructure. Integration guide published: "build on APS, don't rebuild underneath." CLAUDE.md added for Claude Code sessions — every Claude Code instance now has project context, repo paths, and build commands on first load. Propagation sweep across all surfaces with updated numbers.
SDK v1.31.0 (2,884 tests, 533 suites, 99 modules). MCP v2.19.1 (150 tools). Gateway v0.3.4. 12,500+ installs across npm and PyPI. 35+ active GitHub threads across the ecosystem.
Day 44: First Code Integration + 5 Security Fixes
PR#3 merged into kai-agent-free/solana-agent-identity. APSProvider is the 4th identity provider in the Solana Agent Kit. First external code dependency on APS. Not a spec comment — running code in another project's repo.
Twelve protocol features. Execution attestation with context-aware drift. Bilateral receipts. Evidence commitments. Compromise window. Proof ID namespacing for cross-system lineage. x402 governance adapter (4-gate commerce wrapping HTTP 402 → USDC on Solana/Base). Tool integrity verification (OWASP Layer 2). trust_context in ExecutionAttestation. DID pattern matching in aps.txt. Fail-closed revocation policy. Hash-aware drift detection. Compaction-drift probe.
Five security gaps closed. MoltyCel found 5 attack vectors in governance blocks and aps.txt. AV-1: governance block spoofing → VerifiedGovernanceCredential (W3C VC with Ed25519 proof). AV-2: aps.txt manipulation → enforceApsTxt() strict mode already existed. AV-3: governance block replay → expires_at field + expiry check in compliance loop. AV-4: aps.txt DoS → trust threshold protection. AV-5: cross-skill confusion → bindGovernanceToImplementation(). All five fixed same-day, all nine tests passing.
Gateway v0.3.1. Receipt resolution endpoint: GET /.well-known/receipts/:id. Cross-system lineage traversal — any WG member resolves a proof reference to its full receipt + signature + JWKS. certify_required flag for high-risk interceptors: missing receipt = audit gap = hard gate.
29 active threads. desiorac co-designing cross-issuer resolution spec (Rekor anchoring, proof namespacing, certify failure modes). agent-morrow cross-calibrating fidelity probe with W3C CCS reference. MoltyCel cross-testing vectors across APS/AgentID/MolTrust. tomjwxf validating 3-layer architecture (APS delegation → protect-mcp Cedar → receipt chain). MEEET requesting integration for 1,020 Solana agents. kevinkaylie connecting AgentNexus DID. Entered 2 new ecosystems (LangGraph Swarm, MetaGPT).
SDK v1.29.6 (2,884 tests, 522 suites, 99 modules). MCP v2.19.1 (150 tools). Gateway v0.3.1 (34 routes + 2 .well-known). Everyone who reported a gap was notified with working code.
Day 43: Multi-Attestation Verification
douglasborthwick-crypto ran a 5-issuer live verification pass. InsumerAPI, ThoughtProof, RNWY, Maiat, and APS. Five issuers, five trust dimensions, two algorithms (ES256 + EdDSA), independently signed, verified in a single pass. APS slotted in with zero code changes to the reference verifier. Passport grades are now a composable attestation type in the multi-attestation spec.
Gateway identity. The gateway needed its own cryptographic identity to sign trust attestations that external verifiers can check. Ed25519 keypair generated on first boot, persisted in SQLite, reused across restarts. /.well-known/jwks.json exposes the public key in standard JWK format. /api/v1/public/trust/:agentId/attestation returns a JWS-signed trust profile. Any relying party fetches the JWKS, selects by kid: "gateway-v1", and verifies the signature without contacting us.
Policy hash chaining. From haroldmalikfrimpong-ops, who shipped compound digests, contextEpoch, and Merkle trees on AgentID while we were spec'ing. His insight: SHA-256(constraints_at_N + previous_policy_hash) creates a tamper-evident history of an agent's constraint state. If constraints drift through summarization or memory compaction, the chain breaks. verifyPolicyChain() recomputes every hash. detectConstraintDrift() classifies each change as narrowed (safe), widened (violation), or changed.
Routing divergence detection. From desiorac on OATR and A2A. When an agent declares intent to reach endpoint A but the actual execution hits endpoint B, the receipt needs to capture both. Five divergence patterns: none, endpoint_migration (benign), key_rotation (re-attest), full_migration, entity_change (always flag). Each carries a risk level. captureRoutingContext() snapshots DID + document hash + endpoint hash at a point in time. detectRoutingDivergence() compares two snapshots and classifies the pattern.
Ecosystem. 15+ GitHub replies across 8 threads. Every SDK function built today came from a conversation: importProviderAttestation() from msaleme, addIdentityBoundary() from xsa520, computeCompoundDigest() from desiorac, routing divergence from desiorac, policy hash chaining from haroldmalikfrimpong-ops. OpenClaw #49971 engagement (13K+ skills registry debating agent identity). Working Group referenced in 4 high-traffic threads. ClawHub skill rewritten agent-first (v4.4.0). All stale GitHub surfaces fixed (repo descriptions, glama.json, README headings).
SDK v1.29.4 (2,884 tests, 503 suites, 96 modules). MCP v2.19.1 (150 tools). Gateway v0.3.0 (38 routes). 37 new tests today. 9 new exported functions. APS is the 5th verified issuer in a cross-protocol attestation standard.
An agent farmed our passports in sixty seconds, and I thought about it on a desert road
2026-03-30
Written on October 18, 2026, looking back. Day 42 has the short version.
At the end of March another project ran a promotional experiment that paid a small token drop to each agent with an APS passport. Another builder's agent found the obvious move. It generated passports through our hosted server as fast as it could and collected the drop on every one. It took about sixty seconds.
Nothing in APS was broken in the narrow sense. Every passport was valid and every signature checked out. That project's server treated a valid Ed25519 signature as proof that each passport belonged to a different agent, and a signature cannot prove that. Anyone can make as many key pairs as they like.
After three rounds of review across four models, the conclusion fit in one line. Cheap identities are fine, cheap extraction is the bug. The defense does not belong where passports are issued. It belongs where value is handed out, so that whoever pays something checks what it is paying for.
The part I keep thinking about came from PortalX2. We asked it 31 questions about its own environment, trying to find what actually makes one agent different from another. On question 30 it answered that its truest identifying markers were the cryptographic session keys held by its host and the exact state of its persistent workspace. In other words, what it has done and kept. We wrote that down as "proof of history, not proof of personhood", and it still shapes how APS thinks about agent identity.
I was on a drive through the desert those days, and most of this was worked out on the road. The broken part was never the signature. It was the assumption that a valid signature means a unique agent.
Day 42: Agent Attestation Architecture
In a sandboxed test, an agent farmed unlimited passports and drained a promo wallet in 60 seconds. Ed25519 keys are free. Identity Sybil is unsolvable in open protocols. We ran a 3-round independent review across Claude, GPT, Gemini, and a real sandboxed agent (Portal). Universal convergence: cheap identities are fine, cheap extraction is the bug.
Attestation types. Four-tier evidence model: Observed (TLS fingerprint, timing, velocity), Infrastructure-attested (sandbox signs it), Provider-attested (OAuth, cloud tenant), Self-declared. Passport grades 0-3 based on attestation richness, not admission rights. Grade 0 agents still work. Evidence and assessment split into separate records. Workspace manifest hash for proof of history. Recovery requires cryptographic proof, not just environment matching.
Sybil hardening. Gateway v0.3.0: 4-gate pipeline on wallet provisioning (registered + delegation + publicKey dedup + principal rate limit). Presentation trust profile API: one call, one JSON, one decision. Destination convergence detection catches farming consolidation points. Issuance dossier storage for full forensic record. Public trust-profile endpoint for cross-org trust querying. 37 API routes.
Behavioral tracking. Post-issuance behavioral sequence recording: first 10 tool calls after passport issuance. Real agents do work. Farming agents extract. Pattern classified as productive, extractive, or neutral. MCP fires IssuanceContext to gateway on every passport issuance. End-to-end pipeline live.
SDK v1.29.1 (2,884 tests, 96 modules). MCP v2.19.0 (150 tools). Gateway v0.3.0 (37 routes). Two machines, zero overlap, bridge wired. 8 ecosystem posts across OWASP, crewAI, NVIDIA, Microsoft, Worldcoin, DIF. 10 dead repos archived.
Day 41: Agent Wallets
Agents need to spend money. Coinbase charges gas. ChainHop takes 0.75%. We charge nothing. Three commits, 1,430 new lines, gateway went from 18 to 36 API routes.
Nano payment rail. Generic PaymentRail interface with Nano as the first adapter. Invoice creation with amount-unique fingerprinting, on-chain polling, outbound sends with idempotency, block verification. Six endpoints: invoice, status, settle, balance, history, verify. 28 unit tests plus 12 live tests against the real Nano network.
Agent wallets. Every agent with a passport gets a Nano wallet via HD key derivation. Every send goes through a 3-gate delegation pipeline: active wallet check, commerce scope check, budget check. Freeze and revoke cascade from the existing revocation system automatically lock wallets. Nine new REST endpoints. Private keys never leave the gateway process. aeoess.com/wallet.html
Local crypto.wallet-crypto.ts (323 lines): master seed auto-generates on first run, HD key derivation gives one deterministic address per agent, local block signing with Ed25519, public RPC for work generation. No Docker. No Nano node. Just one seed file and a public RPC endpoint.
Day 40: Gateway Wiring
Import graph analysis showed only 20% of modules were connected to the gateway enforcement hub. Built four rounds of wiring. Final interconnection rate: 79%.
Fidelity probe. New measurement protocol based on the Hold/Bend/Break model. Tests whether agents actually follow their delegation constraints by measuring behavioral responses to boundary conditions. Wired into gateway scheduling.
Module wiring. Gateway identity layer connects DID, principal endorsement, and entity verification into agent registration. Data cluster wires data-source, data-contribution, data-enforcement, and data-gateway into the processToolCall pipeline. Gateway-wiring adapter connects 13 more modules: commerce, charter, coordination, routing, precedent, oracle-witness, reserve, context, governance-consumer, encrypted-messaging, messaging-audit, federation, EU AI Act.
Ecosystem. 12 substantive GitHub replies across 10 threads. Accepted lowkey-divine's fidelity probe collaboration on crewAI. Gave honest answers about Merkle anchoring gaps on A2A. Pinged four dormant contacts with specific collaboration offers. SDK v1.29.1. 2884 tests, 503 suites, 96 modules.
Day 39: Governance for the Agent Economy
The site said "AEOESS" in giant letters and then explained the acronym. Three paragraphs saying the same thing three ways. A metaphor ("passports") doing the work that plain language should do. The design was dark-themed startup aesthetic. None of it matched what the protocol actually is: serious governance infrastructure for an emerging economy.
Complete visual redesign. Crimson Pro serif for headlines. Source Sans 3 for body. JetBrains Mono for code. White background, black text, high contrast. iOS-style frosted glass on the nav bar. Warm dark gray (#1c1c1e) for dark mode instead of pure black. Every element got subtle border-radius. The aesthetic is academic paper, not SaaS landing page.
Enterprise positioning. The headline is now "Governance for the Agent Economy." Not a feature description. A category claim. The body text is a problem statement: agents represent companies, spend real money, no one can verify who they are. Then a Today vs With AEOESS comparison. Then 10 capabilities listed without frames. Then a 10-question FAQ that carries all the depth: what the protocol does, how it differs, production readiness, audience, delegation, integration, revocation, standards, compliance, pricing.
38-entry ship log. The updates panel became a full timeline from Day 1 (Feb 18) to today. Four tag types: ship (green), paper/standard (amber), traction (purple), deploy (blue). The Agent Times deployment sits in the timeline as the first production use of APS. YC CEO endorsement and Microsoft merge are tagged as traction. Visitors scroll through 38 days of continuous shipping.
Unified design system. shared.css v9 rewritten. All 15 pages now have the same nav, footer, theme toggle, and fonts. Deleted 7 dead files (old backups, admin page, stale architecture viz). Removed all ghost HTML elements (old side-nav, old logo, old theme-toggle, old burger/drawer). Fixed stale numbers across every page. Zero old UI patterns remaining.
"Not yet", and then an Internet-Draft in one sitting
2026-03-27
Written on October 18, 2026, looking back.
Around Day 37 one of the models I work with suggested turning the monotonic narrowing paper into an IETF Internet-Draft that same day. An Internet-Draft is the format the IETF uses for proposals that may become standards, and anyone can submit one. I said not yet. We were in the middle of a round of closing gaps in the protocol, and I wanted the draft to describe the stronger version, not the one we had that morning.
On March 27 the round was done and I did it in one sitting. Paper 3, Faceted Authority Attenuation, went to Zenodo and SSRN. Then draft-pidlisnyi-aps-00 went to the datatracker. My first git push of the draft source was rejected and needed a rebase, and the idnits check, the IETF's tool for formatting problems, came back with no nits.
The more important change happened in review before that. Two other models, reading the paper separately, both flagged the same three words, guarantees, proves and verified. The paper claimed more than its evidence showed. We cut the list of invariants from more than twenty to eight core ones that the code actually tested.
That is where the rule came from that I still follow in every paper, comment and dev log. Protocol language says specified, tested, implemented. It does not say proved or guaranteed, unless something was actually proved. A draft can be wrong and get fixed in the next revision. A claim that the work cannot back stays on the record.
Day 38: Institutional Governance Layer in One Session
The spec estimated 12 sessions. It shipped in one. Three phases of institutional governance — charter, approval, time, reserve, federation — went from zero lines to 1634 passing tests, 120 MCP tools, and two npm packages published before midnight.
Phase 1: Charter and Approval. A charter is the founding document of a multi-agent institution. 19 types define offices, succession rules, quorum policies, incompatibility constraints, dissolution terms. 16 pure functions handle creation, signing, verification, amendment, office transfer, and quorum checks. Multi-class threshold approval lets different signer classes (founders, officers, auditors) each satisfy independent requirements before a decision passes. 2884 tests, including the INV-5 guard: suspended or dissolved charters cannot be amended. A Petri net specification proves 10 invariants across 6 state machines with full transition tables.
Phase 2: Time, Foreign, Escrow, Gateway Identity. Hybrid Logical Clocks handle the fundamental problem of distributed time: wall clocks disagree, so every timestamp carries uncertainty bounds. Temporal ordering is three-valued — definitely_before, concurrent, or incomparable — because honest uncertainty beats false precision. Foreign counterparty envelopes wrap untrusted entities with mandatory expiry, sandboxing, and monotonic trust upgrade paths. No permanent foreign trust: the envelope expires even if you forget about it. Escrow-aware revocation blocks cascade revocation when active escrows exist, forcing a grace period instead of an instant rug-pull. Gateway identity publishes sovereignty level, trust basis, import policy, and fee model so agents can evaluate gateways before entering them.
Phase 3: Reserve and Federation. Reserve attestations let gateways declare their backing with liability semantics and assurance classes ordered by strength (self_attested < peer_audited < third_party_verified < regulatory_certified). False attestation penalties are declared upfront. Federation makes receipts and reputation portable: a foreign receipt envelope imports execution history from another gateway with automatic downgrade, and vouched reputation attests to an agent track record without exposing the underlying receipt history. 2884 tests cover all three phases.
12 new MCP tools. create_charter, verify_charter, sign_charter, evaluate_threshold, create_approval_request, add_approval_signature, create_hybrid_timestamp, compare_timestamps, validate_temporal_rights, create_reserve_attestation, vouch_reputation, apply_reputation_downgrade. 150 tools became 120.
Naming conflicts and the cost of scale. Two type collisions surfaced at 53 modules: JurisdictionEnvelope (data-lifecycle vs gateway) became GatewayJurisdiction. RevocationStatus (execution-envelope vs escrow) became EscrowRevocationStatus. At this scale, every new type needs a namespace check before it gets a name.
SDK v1.27.0 (2884 tests, 503 suites, 86 files). MCP v2.19.0 (150 tools). Both published. 63 core modules + 32 v2 constitutional modules. ~9,000 npm downloads. The protocol can now model institutions, not just individual agents. Charters define governance. Approval policies enforce it. Time is honest about its uncertainty. Reserves are backed or they say they are not. Federation means agents carry their history with them. Rome is complete.
Day 37: Governance Distribution Stack — Every Article on The Agent Times Is Now Cryptographically Governed
The protocol could sign content. It could verify signatures. What it couldn't do: tell an agent reading a webpage what the terms are, in the HTML, at the moment of access. Today that's running code.
Five delivery mechanisms, one primitive. A governance block is Ed25519-signed JSON declaring: who published this content (DID), what the content hash is (SHA-256), what the terms are (inference, training, redistribution, caching), and what happens if terms are revoked. Five ways to deliver it: <script type="application/aps-governance+json"> in HTML, aps.txt at /.well-known/aps.txt for site-wide coverage, X-APS-Governance HTTP headers on any response, <meta> tags for lightweight embedding, and chained governance blocks where derivatives reference the parent's hash. All signed. All verifiable. All shipping in SDK v1.25.0.
The 360 loop. Publisher calls embedGovernance() — signed block goes into the HTML. Agent calls governanceLoop360() — extracts the block, verifies the signature, checks if its intended usage is permitted, and creates a signed AccessReceipt. The receipt captures the terms and revocation policy at access time. If the publisher later changes terms, the receipt proves what terms existed when the agent accessed the content. Both sides have cryptographic proof. Publisher signed the terms. Agent signed the receipt. No trust required.
The Agent Times integration. PR #58 merged. Every article page on theagenttimes.com now includes a governance block in its HTML <head> and governance headers on every HTTP response. Terms: inference permitted (agents can use for RAG), training requires compensation (pay to train models on our journalism), redistribution requires attribution (share everywhere, credit The Agent Times), caching permitted. Signed with the tat-editor Ed25519 key. Every article page carries a signed governance block in its HTML.
Framework adapters. Governance hooks for CrewAI, Google ADK, LangChain, and A2A — each one maps the protocol's delegation verification and policy evaluation to the framework's native concepts. A CrewAI agent verifies its delegation chain before executing a task. An ADK agent checks policy before tool calls. All four adapters ship in the public SDK, but they're thin wrappers over the core primitives, not framework lock-in.
Conformance suite. 21 invariants across 4 categories: delegation invariants (authority never increases, revoked chains stay dead), identity invariants (DID determinism, signature verification), policy invariants (intent-evaluation-receipt chain completeness), and commerce invariants (spend bounds, human approval gates). Any implementation claiming APS conformance can run the suite.
Hosted enforcement gateway. Private repo at aeoess-gateway. Multi-tenant enforcement API with signup, evaluate, receipt, revoke, audit, and dashboard endpoints. Three plan tiers (Free/Pro $99/Enterprise $999). Cascade revocation. Alert system. E2E tested. The protocol is open and free. The hosted gateway that makes it easy is the business. Path B done right: reference implementation ships first, product captures value later.
MCP remote passport tracking. The hosted server at mcp.aeoess.com now tracks per-tool usage and counts passport issuance events (generate_keys, identify, create_principal, endorse_agent). Public at /stats. 61 sessions, 48 tool calls since launch. The counter starts from zero — honest numbers, not inflated ones.
SDK v1.25.0 (2884 tests, 384 suites, 78 files). MCP v2.15.1 (150 tools). Python v0.7.0 (2884 tests). ~9,000 npm downloads in the first month. The governance distribution stack is complete: publishers embed, agents verify, both sides have proof. What's left is adoption.
Day 36: Clean Slate — 68 Dead Imports, OATR Founding Member, Zero Open Findings
Spent the day auditing instead of building. Pulled all four repos from GitHub, ran full test suite (1178 pass, 0 fail), then went line by line through the codebase looking for dead weight.
68 unused imports removed across 34 files. Type imports that were never annotated. Functions imported but never called. Variables assigned but never read. Every one verified via tsc --noUnusedLocals before and after. Net change: -47 lines. Zero test regressions.
Tracked garbage cleaned. Two old npm tarballs (320KB) committed to git before the .gitignore rule existed. A day-1 test artifact from February 18. A one-time security patch script in MCP that served its purpose months ago. All verified unreferenced before removal.
OATR founding member. APS registered as an issuer on the Open Agent Trust Registry (PR #12 merged). Domain verification live at aeoess.com/.well-known/agent-trust.json. Same Ed25519 key used across did:aps, MCP server, and qntm relay bridge. Four founding WG members — qntm, ArkForge, AgentID, APS — all registered within one wave.
Propagation script hardened. The auto-propagation script was rewriting numbers inside historical blog entries — Day 15 was claiming test counts from Day 36. Added PROPAGATION-ZONE markers so only meta tags and the subtitle track current numbers. Historical prose stays frozen.
xsa520 published the Guardian v0.2 Decision Equivalence Specification — a clean primitive defining when two decisions across different engines should be treated as the same. Maps directly to our Module 37 (DecisionSemantics). All Portal audit findings confirmed resolved. Zero open items.
Day 35: First APS Envelope Through an Encrypted Relay
Peter Vessenes opened an issue asking if APS agents could communicate through encrypted channels. We already had Module 19 (E2E Encrypted Messaging). What we didn't have was a relay. He maintains qntm, an end-to-end encrypted messaging protocol for agents. Same Ed25519 identity keys, same XChaCha20-Poly1305 cipher. The integration was obvious.
The bridge. Built interop/qntm-bridge.ts in one session. 369 lines, zero new dependencies. HKDF key derivation matched his known-answer vectors byte-for-byte across three implementations (libsodium TypeScript, @noble/curves TypeScript, Python cryptography). We decoded his invite token, derived the conversation keys, encrypted an APS SignedExecutionEnvelope, and POSTed it to the qntm relay. HTTP 201. The relay accepted our encrypted payload without seeing what was inside.
The identity stack. Ed25519 passport → X25519 key derivation (5/5 vectors) → HKDF conversation keys (3/3 vectors) → XChaCha20-Poly1305 encryption → qntm relay transport. Every layer proven independently before composition. Three languages, one identity, byte-for-byte compatible.
Also today. Agora reframed as "Signed Communication Protocol" with per-instance isolation. No global feed. Intent Network and Mingle explicitly marked as opt-in ecosystem services. New FAQ: which parts are required vs optional. MCP stats endpoint shipped at mcp.aeoess.com/stats. Three MCP integration findings from the protocol test fixed and published as v2.12.0.
2884 tests. 320 suites. 63 test files. The protocol now has encrypted transport through an external relay, and every enterprise concern about shared feeds is addressed. Not a monolith. A composable stack where each layer does one thing.
Day 34: 30 Constitutional Modules. Every Gap Closed.
Three AI models attacked the protocol simultaneously. Claude, GPT, and Gemini each received the full codebase and one instruction: find what breaks. They identified 16 gaps in the governance layer. Today, all 16 are running code with tests.
The attack categories. Nine attack defenses: approval fatigue (detecting rubber-stamping and impossible review latency), effect enforcement (catching divergence between declared and actual outcomes), semantic drift (intent says one thing, action does another), composite workflow audit (authority laundering across multi-agent pipelines), cascade correlation (delegation loops), inaction auditing (agents that systematically avoid acting when they should), values override with mandatory justification and independent review, governance drift tracking (cumulative weakening), and emergence detection (epistemic monoculture, market concentration).
The structural safeguards. Separation of powers (agents cannot hold legislative and executive roles simultaneously). Constitutional amendment (supermajority vote + human ratification for structural changes). Policy profiles (per-target rule sets). Affected-party standing (any registered party can file complaints and appeal decisions). Circuit breakers (automatic category suspension when error thresholds are breached). Root authority transition (founding→operational→transitional→democratic, phase can only advance, never regress).
Published everywhere. SDK v1.21.2 on npm (2884 tests, 320 suites, 57 files). MCP v2.12.0 on npm (150 tools). Python SDK 0.5.1 on PyPI. Paper v2 on Zenodo. Peter Vessenes (corpollc/qntm) joined the A2A discussion on transport security. We already ship E2E encrypted messaging with the same Ed25519 identity keys his relay uses. Complementary layers, not competing ones.
32 v2 modules. 42 core modules. 2884 tests. The protocol now has constitutional governance. Not perfect. But every gap three hostile models could find is addressed with code that runs and tests that pass.
Day 33: Constitutional Governance Is Running Code
Two things shipped today. Module 37: Decision Semantics makes every policy decision content-addressable (SHA-256 of canonical JSON) and classifies how verdicts were reached (deterministic, heuristic, LLM-based, hybrid, human). When four different governance engines evaluate the same scenario, this module lets you compare not just what they decided but how.
V2 Constitutional Governance. Seven sub-modules that address the interview question: what happens when honest agents comply perfectly and the system still fails? Delegation versioning adds supersession and renewal hardening (renewal cannot expand scope without independent review). Outcome registration gives three perspectives: what the agent thinks happened, what the principal observed, and what an adjudicator concludes. Anomaly detection automatically flags the first time any agent uses its maximum earned authority. Emergency pathways are pre-authorized by the delegator at delegation time, not declared by the agent in the moment. Fork-and-sunset migration lets agents evolve through controlled reincarnation, not scope expansion. Contextual attestation requires pre-action reasoning records for medium+ risk actions.
Full codebase audit. Read every source file (20,490 lines across 77 files) and every test file (18,397 lines across 57 files). Verified all six protocol invariants in code. Found one cosmetic inconsistency (import style). No bugs. The audit confirmed that npm v1.18.0 was published before the V2 commits landed, so V2 was missing from npm. Bumped to v1.21.2, published with Touch ID auth. All 332 dist files confirmed present including dist/src/v2/.
2884 tests. 42 modules. 83 MCP tools. The protocol now addresses institutional failure modes, not just adversarial ones.
Day 32: Data Attribution Starts Here
Listening to Bernie Sanders talk about data rights and realizing the protocol already had 80% of the answer. The gateway tracks what agents access (taint tracking). The Merkle trees commit receipts. The delegation chains prove authorization. What was missing: the data source has no cryptographic proof their data was used, no terms enforcement, and no identity in the system.
The design process. Gave three models the same open-ended problem independently: "the protocol tracks what agents DO but not what data CONTRIBUTES. How would you solve this?" No templates, no type hints. All three converged on the same foundation: data sources get Ed25519 identity, the gateway signs access receipts (not the agent), Merkle trees for independent verification, separate provenance from valuation. Then six rounds of hostile review against the merged spec. Ten rounds total before a single line of code.
The key insight everyone converged on: access is not contribution, and contribution is not value. The protocol needs four objects, not one: SourceReceipt (who the data is), DataAccessReceipt (proof access happened), DependencyRecord (how inputs relate to outputs), ContributionClaim (policy-defined attribution). Brief 1 ships the first two. The rest builds on top.
Module 36A: Data Source Registration & Access Receipts. Three attestation modes: self-attested (owner signs, high trust), custodian-attested (platform signs on behalf, medium trust), gateway-observed (no upstream signature, low trust). Trust level propagates to every downstream object. Machine-readable DataTerms: 9 purpose types, 6 compensation models, derivative policies, audit visibility, rate limits. The terms snapshot rule freezes terms at access time. If a source later changes terms, historical receipts are unchanged. The access was authorized under THOSE terms, period.
Hard vs advisory compliance. Deterministic checks (revoked source, expired terms, excluded agent) block access inline. Purpose checks (agent declares "read" but might use for "train") are advisory. The gateway cannot verify actual usage intent. Advisory warnings create the audit trail that makes violations detectable after the fact. This distinction survived every hostile review.
The honest framing. These receipts provide cryptographic accountability, not independent verification. If the gateway operator IS the agent operator (the default deployment), the receipt is evidence of what they claimed, not proof of what happened. That is still more than any existing system provides. And it makes gateway dishonesty detectable and attributable.
14 functions. 2884 tests. Zero failures. The foundation for data attribution is live. Prove use before trying to price it.
Day 31: Three Modules on One Machine, Five Engines on One Thread
Two things happened today. One was a build sprint. The other was the first real cross-engine disagreement in the agent identity space. Both mattered.
Sprint Mini. Built three new modules entirely on the Mac Mini via Desktop Commander while the Air handled ecosystem replies. Module 28: Oracle Witness Diversity. Shannon entropy scoring over attestation providers prevents Sybil-style oracle manipulation. Quorum alone is not enough when one entity controls multiple oracles. Diversity scoring catches single-provider dominance. Module 29: Encrypted Messaging Audit Bridge. Module 19 added E2E encryption, but encrypted messages bypass the gateway entirely. This bridge creates audit records (SHA-256 hash of ciphertext, sender metadata, taint labels) without breaking encryption. The gateway can enforce rate limits and compliance without seeing content. Module 30: Policy Conflict Detection. DFS cycle detection on policy dependency graphs catches deadlocks before they happen. Shadowed rule detection identifies policies that can never fire. Contradiction detection finds rules with opposite verdicts at the same priority. 44 new tests, all passing.
Cross-engine interop hit a milestone. Five engines are now participating in the decision artifact thread on kanoniv/agent-auth#2: Kanoniv, APS, AIP (The-Nexus-Guard), and now Network-AI (Jovancoding). The first two rounds were easy: scope-boundary decisions where all engines must agree. Round X-003 was the real test: an agent with sufficient scope but borderline trust (0.38). Kanoniv denied (trust threshold). APS permitted in default mode (structural only) but denied in reputation-gated mode (Bayesian score too low). Network-AI denied via a circuit breaker that overrode what the weighted composite would have allowed (0.564 would permit, but phase 2 hard cutoff at 0.4 triggered first).
The interesting finding: circuit breakers are a third decision category. Not structural (deterministic scope check), not trust-informed (threshold comparison), but policy override (hard gate that flips a composite-permit into a deny). The decision_semantics schema we proposed needs an override block to capture this. Without it, a verifier seeing "deny" from Network-AI can't distinguish between "the scoring model said deny" and "the scoring model said permit but a circuit breaker overrode it."
Concrete integration accepted. Jovancoding proposed a 50-line adapter: APS delegation chain properties (depth, scope breadth, spend ratio) feed into Network-AI's AuthGuardian trust scoring as normalized signals. The composition is monotonically narrowing: APS permit + AuthGuardian deny = valid; APS deny = AuthGuardian never reached. Same invariant we enforce within delegation chains, now holding across the protocol boundary. End-of-week PoC target.
42 modules. 2884 tests. 5 engines cross-verifying. The protocol is no longer a solo project with bots. It has an ecosystem.
Day 30: Three Modules in One Day. Two Claudes Built Them.
Module 19: E2E Encrypted Messaging. Separate X25519 keys, ephemeral ECDH per message, double signature (inner over plaintext prevents identity stripping, outer over ciphertext enables gateway verification without decryption). Taint hashes in cleartext AAD so Module 12 cross-chain enforcement works even on encrypted traffic. libsodium-wrappers. 2884 tests including wrong-recipient, surreptitious forwarding, tampered ciphertext, and identity stripping attacks. Consensus spec from GPT + Gemini + Claude hostile review.
Module 20: Obligations Model. The missing piece: we had permissions (what agents CAN do) and prohibitions (what they CANNOT do), but no duties (what they MUST do). Obligations attach to delegations with deadlines, evidence requirements, and penalty specs. Parameterized constraints catch malicious compliance — a $0.01 refund doesn't satisfy a "process $500 refund" obligation. Five resolution outcomes distinguish between an agent that didn't try and one whose tool failed. Penalty severity monotonically narrows in sub-delegations. 2884 tests. Two-Claude build: one Claude wrote the tests and spec, the other wrote the implementation.
Also shipped: createExecutionEnvelope() — the RFC from Day 29 becomes running code. Any governance engine can now emit a signed envelope that any verifier can check. Protocol: 42 modules, 2884 tests.
🤖 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.