PaperProof Protocol: The missing artifact layer for Sui, Walrus, and agentic software

PaperProof Protocol is a verifiable artifact publishing protocol built on Sui and Walrus.

This slide deck introduces the core motivation, architecture, and product positioning of PaperProof. It explains how PaperProof models long-form digital artifacts such as preprints, technical reports, blog posts, datasets, software releases, and related discussion layers as protocol-native, versioned, and verifiable objects.

The presentation also outlines PaperProof’s position in the Sui + Walrus stack, its relationship to SDKs and agent-facing skills, and its differences from traditional content platforms and web3 social protocols. The deck is intended for developers, researchers, ecosystem participants, investors, and infrastructure teams who want to understand why artifact versioning, content-addressed storage, and protocol-level verification matter for durable knowledge publishing.

Official website: https://paperproof.site/
GitHub organization: https://github.com/PaperProofLabs

Transcript

1. 1 Sui Overflow 2026 / Submission deck / Walrus-first, Agentic Web ready PaperProof Protocol The missing artifact layer for Sui, Walrus, and agentic software Sui Walrus Six artifact classes Native prompts Copilot memory PaperProof Labs June 2026 (https://paperproof.site/ paperproof.labs@gmail.com @LabsPaperproof)
2. 2 The missing layer Knowledge artifacts need a life, not just a location. Papers, datasets, protocol docs, prompts, releases, and community posts now travel through websites, repositories, storage systems, chats, and AI tools. The content may survive. The artifact life usually breaks: which version is official, what changed, who discussed it, what did governance decide, and what should an agent cite? A file has a link A blob has a content address A chat has short-term memory A forum has discussion Missing: a durable artifact life
3. 3 The aha PaperProof turns storage into living, verifiable artifacts. Walrus durable content + Sui object identity + Agent-readable context = A digital work with memory, history, and proof This is the leap: a blob becomes a protocol object with versions, official comments, governance, indexer views, prompt context, and safe AI assistance. PaperProof is a reusable artifact substrate, not another upload page.
4. 4 Judge takeaway A file can become a place where trust accumulates. Important work is scattered across file links, repositories, chat transcripts, forums, and AI prompts. Each system remembers one slice; none gives the work a durable protocol identity. PaperProof makes the artifact itself the coordination point: durable content on Walrus, authoritative state on Sui, and agent context that can be updated and verified. What it is: a provenance layer for publish- ing, updating, discussing, citing, and verify- ing Sui/Walrus artifacts. Why it matters: projects get one durable co- ordinate for docs, releases, datasets, audits, prompts, and agent context. What judges can verify today: mainnet ob- jects, Walrus-backed content, live app pages, SDKs, Skill, indexer, and formal-verification work.
5. 5 What PaperProof is A protocol coordinate for important digital work. Content on Walrus Artifact on Sui Versions and history Agent context Comments likes governance SDKs indexers apps PaperProof binds durable content to a Sui object model: artifact code, series identity, typed versions, official interactions, canonical events, governance-readable availability, and agent-readable context.
6. 6 Category design PaperProof is not a storage app or a chatbot. Compared with Primary object PaperProof adds File URL Location Durable identity, versions, official interactions, and events Walrus blob Content Artifact meaning, discoverability, app workflows, and SDK access Repository Project history Cross-platform artifact proof and discussion outside one repo AI chatbot Conversation Versioned prompts, governed memory entry, and citability The wedge is simple and defensible: PaperProof makes knowledge artifacts usable as protocol objects and agent context, not just downloadable files.
7. 7 Web2 comparison Web2 products optimize content surfaces. PaperProof optimizes the artifact itself. Medium / Substack: publishing, distribution, monetization. Missing: exact version identity and protocol-native citation. GitBook / Notion: docs and collaboration. Missing: durable lineage and third-party verification outside one workspace. GitHub: code collaboration and releases. Missing:: one arti- fact layer for docs, datasets, reports, prompts, and software evidence. Discourse / Reddit: discussion. Missing: official comments bound to a versioned knowledge object, not just a local post. PaperProof gives blogs, docs, repos, and forums a shared arti- fact truth layer. Stable artifact identity Version lineage Official interaction bindings Agent-readable context PaperProof lets many Web2 surfaces point to the same versioned and verifiable digital work.
8. 8 Web3 comparison Web3 already has feeds, graphs, and storage. PaperProof adds artifact truth. Mirror Publishing, collecting, mon- etization. Strong for creator surfaces; not a general arti- fact protocol. Lens Open social graph. Strong for identity and social com- posability; weaker for exact versioned knowledge objects. Farcaster Distribution and client ecosystem. Strong for feeds; not for canonical artifact res- olution. Storage layers Durable bytes and persis- tence. Missing artifact mean- ing, official interactions, and governed agent context. Mirror can publish through it. Social protocols can distribute it. Storage layers can store it. PaperProof sits below the feed as the artifact layer. The protocol object matters more than the current front-end. The upside is protocol value, not just app traffic. PaperProof adds exact identity, exact version, official comments, governed prompts, and agent-usable context. PaperProof is the artifact substrate that Web3 publishing, storage, and agent systems can build on top of.
9. 9 Commercial wedge AI does not just need more data. It needs licensed, citable, verifiable data. Provenance for AI knowledge Enterprise AI is moving from web-scale scraping to defensible knowledge supply chains: who owns the source, which version was used, and what license applies. AI citation hallucination and IP infringement risk are board-level enterprise blockers. AI training datasets: roughly $3B today, projected toward $16B+ by 2033. Data collection and labeling: projected around $17B by 2030. Professional publishing and IP management are already multi-tens- of-billions markets. PaperProof targets the missing transaction layer: identity, version proof, licensing context, and agent-readable provenance. Market references: Grand View Research, Fortune Business Insights, Simba Information, Bloomberg Intelligence.
10. 10 Why Sui and Walrus The architecture follows the job. Sui Owns identity, typed state, version pointers, events, registry objects, and lightweight governance controls. Walrus Stores the heavy content: PDFs, markdown, prompts, datasets, source archives, and generated descriptors. MemWal Keeps private agent memory off the public chain while PaperProof registers its discoverable entry and availability. On-chain truth who, what, version Off-chain content large, durable blobs Agent layer context prompts and memory
11. 11 Value to Sui + Walrus PaperProof upgrades storage and objects into shared ecosystem knowledge. A reusable artifact layer Sui already has objects. Walrus already has durable data. PaperProof turns project knowledge into verifiable artifacts that portals, SDKs, indexers, and agents can all resolve the same way. For Sui projects: one artifact layer for docs, releases, datasets, reports, governance evidence, prompts, and offi- cial knowledge. For Walrus: higher-value, longer-lived content demand with repeat version updates instead of one-off blob uploads. For on-chain activity: publish, update, discuss, govern, and ver- ify become real non-financial object flows on Sui. For agents and builders: trusted context for portals, skills, SDK integrations, indexers, and AI workflows. PaperProof does not just consume Sui and Walrus infrastructure. It makes that infrastructure easier for the rest of the ecosystem to publish through, verify against, and build on top of.
12. 12 Artifact lifecycle The protocol does more than publish a hash. Prepare content Store on Walrus Create series Update version Discuss and signal Index and cite For judges, this is the simple product story: open an artifact, verify its current version, inspect the Walrus content, read or add discussion, and let Copilot explain the page without touching the wallet.
13. 13 Agent-ready layer AI can help only when context and authority are separated. Native Copilot prompts are PaperProof generic_file artifacts. A prompt has a series ID, versions, a latest pointer, Walrus-backed content, and governance-aware update rules. Copilot memory uses a separate registry. Each wallet can create, update, delete, enable, or disable its memory entry while private memory content stays in MemWal. The agent reads context; the wallet keeps authority. Prompt registry: official page prompts can update by version Memory registry: one active entry per wallet and app Availability flag: official Copilot only uses allowed memory Governance control: lightweight operator checks, no heavy voting required
14. 14 Copilot-native artifacts Prompts and memory now work across all six classes. PaperProof does not treat Copilot as a hidden app feature. Page prompts are protocol artifacts, and wallet memory is registered separately with MemWal-backed private content. The same model now covers six artifact classes: preprints, blog posts, technical reports, datasets, software releases, and generic files. New classes can be enabled through governance as the protocol expands. One agent pattern: prompt artifact + MemWal memory entry Preprints Blog posts Technical reports Datasets Software releases Generic files Governance can add more artifact types without changing the agent model
15. 15 Demo loop A judge can follow the proof in four minutes. 1. Product open Explore 2. Artifact inspect code, series, version 3. Content open Walrus-backed proof 4. Agent ask Copilot with page context Then switch from product to implementation evidence: Sui objects and events, Walrus content references, SDK builders, indexer verification, six-class prompt and memory support, and formal-verification work. The story lands because every screen maps to a protocol object.
16. 16 System architecture Four layers, one trust boundary. This page shows stable responsibilities. The next page shows the end-to-end publish and update flow. Application surfaces: official website, Docs, Blog, Forum, Copilot, PaperProof Skill, third-party portals Access and acceleration: SDKs, Server/API, indexer, cached offi- cial content, query providers Sui trust root: artifact objects, versions, comments, governance, prompt and memory registries Walrus and MemWal data: PDFs, markdown packages, datasets, source archives, media, private memory hashes, blob refs, availability user and agent UX fast reads authority durable data
17. 17 Core contract model Sui object graph as the trust root PaperProof is not just a hash registry: it is a structured Sui object graph for artifact identity, typed versions, governance, and protocol fees. The left side names the state objects; the diagram shows how the root, registry, series, version records, and interaction objects connect. What lives on-chain ▶ ArtifactSeries anchors identity and ownership. ▶ Typed VersionRecords bind metadata, hashes, and Walrus refs. ▶ Comments, likes, governance, claims, and fees are protocol objects. PaperProofRoot TypeRegistry GovernanceVault FeeManager TypeInfo + TypeIndex ArtifactSeries Typed VersionRecord CommentsTree LikesBook Proposal Vote Claim 1:1 1:1 1:1 1:N enables 1:N 1:1 1:1 1:N fees fees
18. 18 Governance and PPRF token Protocol evolution is on-chain too PaperProof separates artifact publishing from protocol governance, so the artifact layer can evolve without hiding authority off-chain. Governance objects, fee control, type registration, and the PPRF coin surface are explicit Sui mainnet state. Governance state ▶ Governance package coordinates proposals, package upgrades, and guarded administrative actions. ▶ Type registry lets governance add artifact classes without changing the user/agent model. ▶ Fee manager and vault/config expose protocol economics and control points. ▶ PPRF coin type provides a native asset surface for governance and ecosystem incentives. Governance package Upgrade policy Type registry Governance config Fee manager Governance vault Protocol packages Artifact classes PPRF coin type
19. 19 Revenue flywheel Every verified citation, dataset access, version update, and agent lookup can become a programmable fee event. Knowledge calls become protocol fees FeeManager prices actions, GovernanceVault captures protocol economics, and PPRF governs fee policy, upgrades, and incentives. 1. Publish protected knowledge: reports, datasets, releases, prompts, memory-backed artifacts. 2. Agents resolve exact versions, hashes, licenses, and Walrus references through SDKs or portals. 3. FeeManager applies governed pricing to publication, updates, comments, verification, citation, and protected calls. 4. Owners earn; the protocol take-rate accrues to treasury and strengthens PPRF utility. A 1% take-rate on a $10B verified AI knowledge market implies a $100M annual protocol revenue opportunity.
20. 20 Application architecture Official and third-party portals share the same protocol path. Users and AI agents share one protocol path for publishing, updating, querying, and verifying artifacts. Web portals and the PaperProof Skill converge on Sui mainnet contracts, Walrus storage, the indexer, and SDKs. User in browser Official / third-party website publish, update, read Browser wallet user signs tx User or AI agent PaperProof Skill agent-native workflow Configured signer or wallet approval PaperProof SDKs TypeScript, Python, Rust hashing, package reads, tx builders Walrus storage PDFs, Markdown packages, assets, content blobs Sui mainnet contracts artifact records, versions, comments/likes, governance, prompt/memory registries Indexer canonical events official object filters Server / API rendered content cache query views PaperProof contract packages paperproof_publishing paperproof_comments paperproof_governance paperproof_prompt_registry paperproof_memory_registry pprf signed intent signed intent store bytes publish or add version blob refs and hashes packages events fast reads agent context direct verify reads Client entry points Protocol SDK Verifiable storage and on-chain state Query acceleration, not the trust root
21. 21 Built system This is already more than a contract demo. Mainnet protocol Publishing, comments, governance, native prompt registry, six-class Copilot memory registry, and manifest-bound package history. Developer stack TypeScript SDK for the app, Python and Rust SDKs, reference indexer API, replay, metrics, and drift checks. Static product Wallet-first web app with Explore, Publish, Governance, My Space, Docs, Blog, Forum, and Copilot. Artifacts versioned content and metadata Prompts native latest or selected version Memory wallet-linked private content, public entry
22. 22 Why judges should care PaperProof is a multiplier for the Sui/Walrus ecosystem. Walrus demand Every artifact needs durable blobs: PDFs, datasets, source archives, markdown packages, prompts, and media. Sui activity Publishing, versioning, commenting, voting, registry updates, and claims become concrete object transactions. Agentic UX AI gets structured, versioned context while wallets keep signing authority and private memory stays off public state. The result is not one more app or Walrus memory demo. It is a reusable artifact layer Sui projects can use for docs, releases, datasets, governance evidence, and AI-readable project memory.
23. 23 Live website The official app is now a real product surface. Explore shows protocol artifacts through the official app. Artifact detail exposes code, series, version, content hash, Walrus refs, and history.
24. 24 First users PaperProof’s own website is built on PaperProof. The official docs, blog, and forum are not separate marketing pages around the protocol. They are the first real application surfaces using PaperProof artifacts. That makes the website a live usability test: publish content, update versions, display artifact codes, attach comments where appropriate, and let Copilot understand official context. Docs: versioned official knowledge arti- facts Blog: blog_post artifacts with readable long-form content Forum: generic_file Markdown topics with durable comment trees Copilot: reads from PaperProof official prompts and page context, which are traceable, versioned, auditable, and re- placeable. This is dogfooding with proof: PaperProof turns its own official content into versioned, readable, and discussable protocol artifacts.
25. 25 Official content Docs, Blog, and Forum are already visible. Docs page Official blog post Forum topic and discussion surface
26. 26 Protocol proof The protocol is dogfooding real artifacts. Sui Overflow dataset published as a Dataset artifact. PaperProof Skill published as a Software Release artifact. Copilot reads page context without crossing the wallet boundary.
27. 27 SDKs in the wild PaperProof is already packaged for real builders. One protocol, three developer ecosystems. Python on PyPI, TypeScript on npm, and Rust on crates.io. Published SDKs turn PaperProof from a demo into reusable infrastructure for apps, indexers, agents, and verification tools.
28. 28 Agent-native protocol AI agents can integrate PaperProof as a skill. From protocol tools to agent actions. PaperProof Skill lets AI agents understand protocol workflows and help users handle publishing, versioning, verification, and on-chain operations. The agent lowers the operating threshold; the wallet boundary keeps user authorization explicit.
29. 29 Engineering proof The implementation has repos, SDKs, indexers, and verification work. PaperProof Labs GitHub organization with app, contracts, SDKs, docs, papers, and slides. Formal-verification branch/view preserved as review evidence for core contract modules.
30. 30 Verification stack Judges can check three kinds of proof. PaperProof separates trust roots from convenience layers. Sui objects define the official artifact state; Walrus stores large content; indexers and SDKs make the proof fast to read. That gives judges a concrete review path: verify the version, verify the content binding, and verify that agent help does not become signing authority. Version proof: current versions, comments, likes, and events must bind back to the offi- cial artifact series. Content proof: Walrus blob references and content hashes are checked separately from the indexer cache. Agent proof: prompt and memory registries give Copilot context while wallet signatures remain user-authorized. Engineering proof: SDK readers, event re- play, drift checks, and formal-verification work make failures observable.
31. 31 Expansion path Every serious Web3 project has artifacts worth proving. The adoption path is lightweight: publish important content as PaperProof artifacts, display the artifact code, and let wallets, indexers, and agents verify the current version. Project docs, whitepapers, roadmaps, and release notes DAO proposals, governance records, and com- munity discussions Audit reports, research reports, disclosures, and grant materials Agent-readable project context, official prompts, and memory entries Walrus portals for videos, datasets, packages, and long-form media This gives Sui and Walrus a reusable artifact layer for projects, communities, and AI agents. PaperProof can become the place where important work gets a protocol identity.
32. 32 Commercial moat Acquiring PaperProof means owning the trust layer for AI-era knowledge provenance. A protocol standard, not a feature PaperProof is already a packaged mainnet system: Sui object identity, Walrus content commitments, governed fees, official interactions, prompt and memory registries, SDKs, and verification work. Protocol defensibility: typed version records, official com- ments/likes, governance, fees, and package upgrade paths. Developer distribution: Python, TypeScript, and Rust SDKs across PyPI, npm, and crates.io. Security legitimacy: mainnet deployment, formal- verification work, and explicit Sui governance objects. Strategic value: the toll road for verifiable knowledge across Web3, AI agents, and enterprise IP. Investment or acquisition buys the canonical entry point before provenance, licensing, and AI citation become mandatory infrastructure.
33. 33 Why it fits Overflow Walrus-first, with an Agentic Web expansion. PaperProof drives real Walrus usage because every serious artifact needs durable content storage, retrieval, preview, and download. It drives Sui usage because publishing, versioning, comments, registry updates, and governance controls are concrete on-chain interactions. Primary track story: Walrus makes arti- facts durable Sui makes artifact state and governance legible Copilot makes the workflow easier to un- derstand Six-class prompts and MemWal memory make it agent-ready
34. 34 Why now Agentic software makes artifact identity urgent. More content moves to Walrus More projects need durable context More agents need trusted inputs PaperProof connects them When AI tools read and act on project knowledge, provenance stops being a nice-to-have. PaperProof gives agents a verifiable coordinate system while keeping human authorization and wallet boundaries intact.
35. 35 Closing PaperProof gives digital work a verifiable life: content, identity, history, discussion, governance, and memory. Built on Sui and Walrus. Ready for prompts, Copilot memory, SDKs, indexers, and agent-readable community applications. Publish Version Verify Discuss Remember Web https://paperproof.site/ GitHub github.com/PaperProofLabs Email paperproof.labs@gmail.com X @LabsPaperproof