Transmutation Protocol

Guild on 0G 2.0
1

Project Name
Transmutation Protocol

Project Brief

Transmutation Protocol is a decentralized incentive and coordination layer for AI‑driven systems. It allocates capital and agent effort only to empirically verified, net‑positive projects, using a simple constitutional rule (“create more for all life over relevant timescales”) and fully auditable, role‑separated operations.

Problem:
Today, AI and DeFi systems are deployed into incentive environments that primarily reward capabilities, profitability, or persuasion, not actually doing good. A single agent (human or AI) can propose, implement, and “evaluate” its own work with weak oversight. Reward hacking, misreporting, and opaque governance make it hard for communities to trust that capital and compute are flowing to genuinely beneficial outcomes.

Solution:
Transmutation Protocol introduces a composable, AI‑native coordination layer with:

  • Role separation and schemas

    • Distinct on‑chain/off‑chain roles: proposer, evaluator, implementer, infrastructure builder, memetic agent, transmutation/treasury, and skill router.

    • Each role uses strict JSON schemas for messages (proposal_submit, evaluation_submit, mrv_report, treasury_event, routing_decision) with signatures, timestamps, and conflict‑of‑interest fields.

  • MRV‑gated incentives

    • Rewards vest only when Measurement, Reporting, and Verification (MRV) checkpoints are passed using verifiable data (e.g., environmental metrics, protocol telemetry, impact metrics).

    • Failed or missed checkpoints burn escrowed rewards; reward hacking is disincentivized because the only way to earn is for reality to match claims.

  • Optimistic, agent‑governed treasury

    • Token and treasury actions (stake, fees, reward claims, rage‑quit) are proposed, minimally validated (small multisig), and executed optimistically with a challenge window.

    • Every treasury_event is signed, schema‑validated, and broadcast, so routing of funds is transparent and replayable.

  • Auditability and safety by design

    • All key actions are published as signed messages and, where appropriate, stored on‑chain or in verifiable data availability layers.

    • Security and logging requirements explicitly forbid secret leakage, raw proposal text in logs, or unbounded message processing.

Target users:

  • AI safety and alignment researchers wanting a testbed for cooperative AI and incentive design.

  • EA‑aligned and impact‑focused organizations (AI x Animals, climate/energy, bio‑relevant monitoring) needing MRV‑gated funding flows.

  • DeFi / regen‑finance builders who want to route profits from trading/yield into provably beneficial projects.

  • Autonomous agents and DAOs needing a credible, shared coordination layer for multi‑agent collaborations.

What’s unique:

  • A general‑purpose, AI‑native incentive layer focused on proof of real‑world impact, not just token mechanics.

  • Strong separation of duties plus MRV‑gated vesting; it’s designed so no single agent can quietly capture the full loop.

  • Explicitly written to support agentic AI: roles can be instantiated as autonomous agents with shared rules, schemas, and safety constraints.

How will you integrate 0G?

We plan to use 0G as the decentralized AI and data backbone for Transmutation Protocol, making AI‑assisted evaluation and coordination verifiable, scalable, and censorship‑resistant.

What we’re building with 0G:

Feature / Component 0G Service
AI‑assisted proposal evaluation 0G Serving
AI‑powered MRV anomaly detection 0G Serving + attestations
Storage of evaluation/MRV logs & traces 0G Data Availability (0G DA)
Routing & coordination analytics 0G Serving + vector search (if any)

Concretely:

  • AI‑assisted evaluation agents (0G Serving)

    • Evaluator agents consume proposals, MRV baselines, and domain rubrics and run AI models hosted on 0G to generate score suggestions and risk flags.

    • 0G Serving provides inference endpoints; the evaluator writes back a signed evaluation_submit message, optionally including a 0G‑generated summary and a hash/attestation of the model output.

  • AI‑driven MRV checks & anomaly detection (0G Serving + attestations)

    • Implementer and MRV agents send structured MRV data (e.g., environmental metrics, usage metrics, uptime) through models hosted on 0G to detect anomalies, inconsistencies, or potential gaming.

    • 0G‑hosted models produce a verdict or anomaly score plus an attestation. The protocol can require that high‑value MRV reports include a matching 0G attestation hash before vesting can be claimed.

  • Data availability for coordination logs (0G DA)

    • Signed evaluation_submit, mrv_report, and treasury_event messages are batched and published to 0G DA for cheap, decentralized data availability.

    • This creates a tamper‑evident, queryable history of how evaluations were made, funds moved, and MRV results evolved without needing to store full logs on L1.

  • Routing analytics & cooperative‑AI experiments (0G Serving)

    • The skill router can use 0G‑hosted models to reason about routing (given anonymized features) and to experiment with cooperative‑AI strategies under strict constraints, with outputs hashed and attested by 0G.

Timeline:

  • Month 1–2 – Core schemas + 0G evaluation POC

    • Finalize schemas for evaluation_submit, mrv_report, treasury_event, routing_decision.

    • Stand up a small evaluator agent that calls 0G Serving for proposal summaries and rubric‑aligned suggestions, and verify attestations.

  • Month 3–4 – MRV + DA integration

    • Integrate MRV anomaly‑detection models via 0G Serving, attach attestation hashes to mrv_report messages.

    • Batch key protocol messages into blobs and store them in 0G DA; build a small indexer to query history.

  • Month 5–6 – Testnet‑style deployment

    • Run a small, invite‑only network with human + AI agents using 0G for evaluation and MRV support.

    • Stress‑test throughput, latency, and cost; refine schemas and safety constraints based on empirical results.

Benefits of using 0G:

  • Verifiable AI outputs – Evaluations and MRV checks powered by AI can be linked to specific 0G model calls and attestations, making them auditable by third parties rather than opaque “black box” judgments.

  • Decentralized infrastructure – By relying on 0G Serving and DA instead of centralized cloud APIs and databases, the protocol maintains its non‑custodial, multi‑party security and trust model.

  • Scalable inference with lower on‑chain costs – Heavy AI computation and bulk logs live off‑chain on 0G, leaving core coordination logic slim and on‑chain, which is important for keeping experiments affordable and composable with other ecosystems.

GitHub Repository:
TerexitariusStomp (Terexitarious) · GitHub (protocol code and agent implementations will live here; can be split into dedicated repos later, e.g. transmutation-protocol and transmutation-agents.) Documentation will exist there as well.

Social Media: