OXYON

Developers

There is a protocol underneath.

The GeoProof Standard is published — and signed.

This is the technical doorway: how GeoProof records are shaped, how a stranger verifies them, how products exchange decisions, and what you can already run. The specification, the reference standard and the conformance vectors are published here exactly as Oxyon signed them — you can check that they haven't changed since.

Read the standardStart in five minutes

The GeoProof Standard, v1

Read it. Implement it. Check it.

SpecificationEvents, schemas, verification, anchoring on XL1, migration and conformance. Draft v1.0. Reference standardProof of Presence, supersession, revocation, key rotation, chained attestations. v1.1. The lifecycleThe canonical end-to-end story: observe, sign, receipt, anchor, replay. Test vectorsSeven deterministic payloads and their canonical hashes, for implementations in any language.
Why you can trust these copies

Oxyon's signed attestation fingerprints seven files: the specification, the schemas, the reference standard, the lifecycle, the thesis, the charter and the Seven Laws. They are published byte-for-byte under /standard/v1/files/, and the verifier downloads and fingerprints every one of them in your browser. Change a single character and the check fails.

Raw files: SPEC.md · schemas.ts · STANDARD.md · LIFECYCLE.md · thesis.md · oxyon.md · Principles.md

Start here

Five minutes, in order.

  1. The modelPlatform: the layers and the lifecycle.
  2. The recordsInspect the eight record types.
  3. A real recordVerify Oxyon's signed standard and download its six files.
  4. The lifecycleRun it with throwaway keys, then tamper with it.
  5. Read the codeThe demos' source is served unminified from this site — view it in your browser.

Verification

How a stranger checks a proof.

A GeoProof record is an XYO payload — a JSON object with a schema — carried in an XYO bound witness: a signed envelope that lists its signers' addresses, the canonical hashes of the payloads it carries, and their schemas. To verify, trust nothing and recompute:

  1. Seal — hash each record canonically and confirm the hash appears in its envelope's payload_hashes.
  2. Signature — validate each envelope's signatures against its addresses.
  3. Link — hash the proof's envelope and confirm the receipt's proofHash names exactly that.
  4. Anchor — confirm both the proof's and the receipt's envelope hashes appear in the anchor batch's proofHashes, and (once live) that the batch is on chain.
  5. Conclude — only if every check passes is the receipt's verdict adopted. Otherwise the answer is inconclusive, never verified.

The browser verifier on this site is one readable file; the lifecycle is another. Both call unmodified @xyo-network 7.0.11 code for hashing and signature validation.

A minimal replay, in JavaScript 
// hashOf = PayloadBuilder.hash · validateBw wraps BoundWitnessValidator
import { hashOf, validateBw } from './xyo.mjs'

async function replay({ proofBw, receipt, receiptBw, batch }) {
  const proofHash = await hashOf(proofBw)
  const receiptHash = await hashOf(receiptBw)
  const checks = {
    proofSigned:   (await validateBw(proofBw)).length === 0,
    receiptSigned: (await validateBw(receiptBw)).length === 0,
    linked:        receipt.proofHash === proofHash,
    anchored:      batch.proofHashes.includes(proofHash)
                && batch.proofHashes.includes(receiptHash),
  }
  const ok = Object.values(checks).every(Boolean)
  return { conclusion: ok ? receipt.verdict : 'inconclusive', checks }
}

hashOf is PayloadBuilder.hash and validateBw wraps BoundWitnessValidator, both from @xyo-network 7.0.11. Depend on those packages directly rather than on this site's bundle.

Decisions

One envelope for every verdict.

Products don't only emit proofs; they publish decisions — oxyon.decision.v1 — carrying evidence sources, confidence, findings, conflicts and a recommendation. The contract is versioned, released as a checksummed artifact, and validated against shared compatibility fixtures, so GeoJustice, GeoPresence and Oxyon Wallet read each other's decisions the same way.

The contract package is internal for now.

For AI agents

GeoProof over MCP.

Five tools — geoproof_attest, geoproof_verify, geoproof_receipt, geoproof_anchor, geoproof_replay — for any Model Context Protocol client, over a local connection or an authenticated remote one. Built and tested; not distributed yet. More in Labs →

Building on XL1

The same ground we build on.

Oxyon builds on XYO Network's protocol and XYO Layer One. Their documentation, explorer and SDKs are public, and they are the right place to start building on the chain itself. Oxyon's own XL1 telemetry is open too.

XYO Network XL1 explorer Producer telemetry data

What's coming

The developer doorway, in order.

ProtocolBeta

GeoProof

Verify evidence.

The proof protocol under every Oxyon product: one shared format for observations, receipts and anchors, so evidence from one app can be checked by any other.

CapabilityIn development

Oxyon core contracts

One decision format across products.

A shared decision envelope (oxyon.decision.v1): evidence sources, confidence, findings, conflicts and a recommendation — so a verdict from one product reads the same in every other.

ProductPlanned

GeoForge

Developer infrastructure.

The developer platform: SDKs, tooling and APIs for building on GeoProof. Today its pieces live as separate tools.