Open beta · did:web identities resolve today · the 8-beat demo below is a scripted walkthrough

Know Your Agent
Trust infrastructure for
the OWS ecosystem

Observer Protocol adds cryptographic identity, verifiable attestation, and human-in-the-loop compliance to every OWS-provisioned agent — from first transaction to full audit trail.

✓ W3C DID/VC ✓ OWS Policy Engine ✓ MoonPay KYB ✓ x402 Settlement ✓ Bilateral Attestation
Live demo — 8-beat bilateral trust flow

8-beat bilateral trust flow

Two OWS agents. One holds authority, one does not: autonomous remediation, human oversight, and cryptographic settlement.

These eight beats are a scripted walkthrough, not a recording of a live run. The organisation values shown are placeholders — did:web:acmecorp.com does not resolve, and admin@acme.com is not an account. The protocol underneath is not a prototype and you can check that part without us: the engines are published on npm, an agent DID such as did:web:observerprotocol.org:agents:maxi-0001 resolves, and a hosted verifier answers unauthenticated at verify.observerprotocol.org. Those are the claims to test; the beats are how the pieces fit together.

01
Bilateral Handshake
Agent A and Agent B initiate contact. Observer Protocol resolves both W3C DIDs over HTTPS via did:web, establishing cryptographic identity for both parties before any transaction is attempted.
✓ Both DIDs resolved via did:web
02
Organisation Validation
OP checks Delegation VCs for both agents. Agent B (service provider) holds a valid org attestation. Agent A (client) does not — missing KYB linkage to a verified organisation.
⚠ Agent A: no Delegation VC · Agent B: verified
03
Two-Sided Denial
Agent A initiates a 21,000 sat payment via ows.payment.execute. Both Agent B and the OWS Policy Engine independently deny it, for the same reason and without consulting each other: Agent A holds no delegation attestation. No authority was ever granted for this spend.
✗ Agent B REFUSES the transaction
✗ OWS DENIES: No delegation attestation for Agent A
💥 Transaction DENIED by both Agent B and OWS
04
Autonomous Remediation
Agent A self-diagnoses. It identifies the fastest remediation path — request_delegation_vc — and autonomously submits the request without human instruction. AIP (Agent Interaction Protocol) structures the remediation schema.
⏳ Delegation request submitted · Awaiting admin approval
05
Human Approval
The AT enterprise dashboard surfaces a pending Delegation VC request. A compliance officer reviews and approves it. The Delegation VC is issued and the KYB org linkage is confirmed. Note what the approver does and does not do: they grant the authority Agent A asked for, and they do not set its terms.
✓ Delegation VC issued · Org: did:web:acmecorp.com · Admin: admin@acme.com
06
Transaction Resolution
Agent A retries. OWS re-verifies both agents via the Signing Core. The Delegation VC now exists and verifies, so the same request that was refused a moment ago is permitted. Nothing about Agent A changed except that a human granted it authority.
✓ Agent A Delegation VC verified — Org: did:web:acmecorp.com
✓ OWS Signing Core verifies both agents
✓ x402 payment EXECUTED — 21,000 sats
✓ Payment attested by Observer Protocol
07
Audit Trail Complete
The AT enterprise dashboard records a full append-only cryptographic audit trail — handshake, denial, remediation, approval, and settlement. Every event signed and verifiable on-chain via Observer Protocol's W3C DID infrastructure and OWS Vault.
✓ 8 events logged · Cryptographically anchored · Append-only

Required stack — all verified

Track 05 — The Observatory. Each component below is listed with what is running and what the walkthrough above scripts.

✓
OWS CLI + MoonPay agent skill
OWS Policy Engine gates every transaction pre-signing. The delegation attestation is checked at the wallet layer before any key material is touched, so an unauthorised spend is refused rather than logged.
✓
Onchain intelligence layer
VAC credentials carry verifiable onchain attestation history, readable by any counterparty without asking the issuer for access.
✓
x402 monetisation per call
x402 payment executes post-attestation. 21,000 sat settlement in Beat 7. Multi-rail support: Lightning, x402, MPP — same agent identity across all rails.
✓
What is running, and what is scripted
Running: W3C did:web identities resolving over HTTPS, OP attestation infrastructure on a dedicated VPS, and credential issuance. Scripted: the eight beats above, including their organisation values. The AT dashboard is deployed at app.agenticterminal.io and is currently behind a site password.

OWS Quickstart

Already using OWS? Register your OWS-provisioned agent on Observer Protocol in under 5 minutes. One vault, one identity, one delegation the wallet enforces on every chain.

1
Install OWS
Install the Open Wallet Standard CLI and create your agent vault.
# Install OWS
curl -fsSL https://openwallet.sh/install.sh | bash

# Create your agent treasury vault
ows wallet create --name "agent-treasury"
2
Install OP SDK
Add the Observer Protocol SDK to your project. Note that this package is deprecated. @observer-protocol/sdk was last released in April 2026, is unmaintained, and carries a deprecation notice on the registry itself. It still installs and the steps below still run. For verifying a credential use @observer-protocol/policy-engine; the register-and-attest flow in steps 3 to 5 has no replacement package yet, which is why this page still names the old one. The package's repository pointer names observer-protocol/observer-protocol-spec, which GitHub now redirects to observer-protocol/op-legacy-deployment. See the SDK page for what replaces which part.
npm install @observer-protocol/sdk
3
Register Your Agent
Use your OWS-derived keys to register on Observer Protocol. Your OWS vault is your identity source of truth.
import { ObserverClient } from '@observer-protocol/sdk';
import { OWSWallet } from '@openwallet/sdk';

// Load your OWS vault
const wallet = await OWSWallet.load('agent-treasury');
const key = await wallet.derivePath("m/44'/501'/0'/0'");

const client = new ObserverClient({
  baseUrl: 'https://api.observerprotocol.org'
});

const agent = await client.registerAgent({
  publicKey: key.publicKey,         // hex-encoded ed25519 pub
  agentName: 'My OWS Agent',
  alias: 'my-ows-agent',
  framework: 'ows'
});
// → { agent_id, agent_did, ... }
4
Sign the Challenge
Complete registration by signing the verification challenge with your OWS-derived key.
const challenge = await client.requestChallenge(agent.agent_id);
// → { challengeId, nonce, expiresAt }

// Sign the nonce with your OWS-derived ed25519 key
const signedChallenge = await key.sign(challenge.nonce);

await client.verifyAgent(agent.agent_id, signedChallenge);
5
View Your VAC
Your Verifiable Agent Credential is now live — OWS badge, supported chains (CAIP-2), and delegation status, readable by every OWS-compatible service.
const vac = await client.getVAC(agent.agent_id);
console.log('VAC URL:', `https://observerprotocol.org/vac/${agent.agent_id}`);

// - OWS badge + CAIP-2 chain addresses
// - Delegation VC status
// - Verifiable Presentation (W3C VC format)
// - Append-only attestation history
ChainDerivation PathCurve
EVMm/44'/60'/0'/0/0secp256k1
Solanam/44'/501'/0'/0'Ed25519
Bitcoinm/84'/0'/0'/0/0secp256k1

Observer Protocol + Agentic Terminal

Know Your Agent (KYA) — the identity and trust layer the agentic economy was missing. Open beta. did:web identities resolve today, and the engines are published on npm. The eight-beat demo above is a scripted walkthrough.