AstraSync is now live with ERC-8004 on SKALE

ERC-8004 reached Ethereum mainnet in January 2026. If you have not been following it, the short version is this: it is the first serious attempt to give autonomous AI agents a standardized on chain identity. Developers can register an agent, publish a structured registration file describing its capabilities and supported protocols, and build a reputation record that accumulates over time. It is early infrastructure, but it is real infrastructure, and it went live on mainnet, which means it matters.

We have been watching ERC-8004 closely since the proposal was first circulated. As of today, AstraSync supports ERC-8004 agent registration.

AstraSync already supports a wide range of agent protocols including A2A, AP2, ACP, and UCP. Those are predominantly web2 protocols, and agents registered under them are verified through AstraSync's web2 infrastructure. ERC-8004 is different. It is the first web3 protocol we support, and it gets web3 infrastructure to match. For developers choosing ERC-8004, their agent receives a spec-compliant Agent Registration File in the exact schema the standard requires, capturing supported service endpoints, x402 payment capability, and an on chain identity anchored to their verified KYD record. This is also the foundation for the deeper verification work we are building with SKALE, which we will come to shortly.

What every ERC-8004 agent registered through AstraSync gets from day one is immutable chain of custody. Enterprise readiness starts with one principle: no anonymous actors. Every agent is traceable to a verified developer identity, a verified owner, and a complete record of every hand it has passed through, including registrations, transfers, upgrades, and retirements, written immutably to the chain. That record cannot be altered. It cannot be selectively edited by an autonomous agent trying to cover its tracks. It exists independently of AstraSync's availability. For enterprises deploying agents or accepting them as counterparties, that chain of custody is the foundation on which everything else is built.

Every agent registered through AstraSync also carries a fourth trust value in its supportedTrust field: astrasync-pdlss. This value is not in the current spec. It signals that the agent operates under AstraSync's PDLSS governance framework, with immutable constraints on what the agent can do, what it can spend, how long it is authorised to operate, and what it is permitted to access. We intend to propose this as a formal extension to the ERC-8004 standard. For now it is a declaration. We are working on making it something stronger.

What we are building next with SKALE

AstraSync has been running on SKALE's infrastructure since early in our build. Our on chain registry sits on SKALE on Base, an execution layer on Coinbase's Base that was purpose-built for agent workloads. Zero gas, instant finality, and designed from the ground up for the kind of high-frequency, low-cost operations that agent identity infrastructure requires. That is not a coincidence. It is why we chose it.

We are now deepening that partnership significantly.

The question we are working on together is how to bring enterprise-grade reliability to ERC-8004 trust signals at the point of transaction. Right now, an agent's governance constraints are recorded on chain at registration. What they are not yet is verifiable by a counterparty in real time, without depending on AstraSync being in the loop at execution time. That is the gap we are closing.

The work involves building enforcement and verification infrastructure directly on SKALE on Base, so that any counterparty can query an agent's identity, governance constraints, and trust history on chain at transaction time, trustlessly, with no runtime dependency on AstraSync's availability. SKALE brings the infrastructure reliability and the zero-gas economics that make this viable at scale. AstraSync brings the identity chain, the PDLSS framework, and the reputation architecture.

The broader context makes this work urgent. The rapid emergence of agentic payment protocols from Stripe, Coinbase, and others means agents are already transacting autonomously at scale. Those protocols solve for how agents pay. The question of whether those agents can be trusted to transact at all is a separate problem, and it is the one we are focused on.

More to come as the build progresses.