Open Grant Proposal: ALX Protocol

# Open Grant Proposal — ALX Protocol

---

| Field | Detail |
|---|---|
| **Project Name** | ALX Protocol |
| **Proposal Category** | Storage |
| **Individual or Entity Name** | Xandr Labs |
| **Proposer** | xandr-labs |
| **Project Repo** | [github.com/xandrlabs/alx-protocol](https://github.com/xandrlabs/alx-protocol) |
| **Filecoin Ecosystem Affiliations** | No existing formal relationships with Protocol Labs, the Filecoin Foundation, or other organizations within the Protocol Labs Network |
| **Technical Sponsor** | None at this time |
| **Open Source License** | Yes — MIT |

---

# ALX Protocol IPFS Grant Proposal

## Project Summary

ALX Protocol is an open verification protocol for AI-generated, human-authored, and machine-produced artifacts. It gives every meaningful output a deterministic identity, verifiable lineage, and portable derivation evidence.

The protocol’s core primitive is the **Block**.

A Block binds an artifact’s content and parent lineage into a single deterministic cryptographic identity. The same content with the same parents always produces the same Block identity across any conformant implementation. Change the content, change the parents, or remove the lineage, and the identity changes.

ALX verification is local computation. Given the Block content and parent hashes, a verifier recomputes the hash to confirm structural validity. No hosted service, blockchain, vendor API, or network dependency is required for the core verification step.

IPFS strengthens ALX by giving Blocks and Block-linked artifacts a content-addressed availability layer.

ALX defines what an artifact is, how its identity is computed, and how its lineage is verified. IPFS provides a natural storage and retrieval layer for the artifact payloads, context attachments, evidence packages, receipts, and graph-linked content that make Blocks useful across systems.

This grant funds the IPFS artifact layer for ALX Protocol: a set of open-source tools, adapters, documentation, and verification workflows that make ALX Blocks retrievable, content-addressed, independently verifiable, and reusable across IPFS-compatible infrastructure.

The result is a reusable pattern for AI-native artifact infrastructure:

1. Create a Block.
2. Store or reference its content through IPFS.
3. Verify the Block locally.
4. Retrieve supporting artifacts by CID.
5. Inspect lineage through verified derivation graphs.
6. Compose downstream systems on top of machine-readable context.

ALX does not require IPFS to function. A Block remains structurally valid wherever its content is stored. But IPFS is one of the strongest compositional layers for ALX because it turns verified artifacts into portable, content-addressed objects that can move across systems without depending on a single vendor, application, or hosted service.

The grant supports the work required to make that integration production-grade.

---

## Why This Matters to IPFS

Most AI-generated outputs are ephemeral.

They are produced inside applications, agent frameworks, RAG systems, evaluation pipelines, compliance workflows, or enterprise tools. They may be useful in the moment, but they usually leave their system of origin without durable identity, verifiable lineage, or portable derivation evidence.

That creates a problem for IPFS and the broader decentralized storage ecosystem.

IPFS is excellent at content addressing and retrieval. But many AI artifacts are not yet structured as durable, verifiable objects worth storing, retrieving, indexing, or composing. Without artifact-level identity and derivation structure, decentralized storage receives opaque files rather than machine-readable evidence of how an output came to exist.

ALX adds that missing artifact primitive.

By structuring AI-generated, human-authored, and machine-produced outputs as Blocks, ALX gives IPFS a new class of useful objects:

- verifiable research summaries
- agent handoffs
- RAG outputs
- compliance evidence
- model evaluation artifacts
- source-grounded reports
- workflow decisions
- human reviews
- policy checks
- context records
- verified derivation graphs

These artifacts are not just files. They are computable objects with identity, lineage, and verification semantics.

That makes them valuable to IPFS because the network is no longer only storing content. It is storing artifacts that downstream systems can verify, reuse, inspect, and compose.

**Core ecosystem thesis:**
ALX expands what IPFS can support by turning AI artifacts into verifiable, content-addressed, machine-readable objects.

---

## The Current Gap

AI systems increasingly generate artifacts that matter: legal drafts, financial analyses, research summaries, model evaluations, compliance reviews, customer workflows, software plans, and multi-agent decisions.

But those artifacts often lack:

- durable identity
- verifiable lineage
- source-grounded derivation
- portable context
- independent verification
- retrievable supporting evidence
- machine-readable structure for downstream systems

Current workflows often depend on platform logs, application state, screenshots, proprietary dashboards, or vendor-specific APIs. Once an artifact moves across tools, vendors, teams, or storage systems, the evidence behind that artifact becomes fragile.

ALX addresses the identity and lineage layer.

IPFS addresses the portable content-addressed retrieval layer.

Together, they create a better pattern:

| Layer | Role |
|---|---|
| **ALX Block** | Deterministic identity + parent-bound lineage |
| **IPFS artifact** | Content-addressed payload + supporting context |
| **ALX + IPFS** | Verifiable artifact with portable retrieval |

This grant funds the integration layer that makes this pattern easy for developers to adopt.

---

# What ALX Adds to the IPFS Ecosystem

## 1. AI-native artifacts with deterministic identity

ALX Blocks give AI-generated and machine-produced outputs deterministic identity. A Block’s identity includes both its content and its parent lineage. That means a Block can represent not only “this artifact exists,” but also “this artifact was derived from these prior artifacts.”

For IPFS, this creates richer stored objects. The CID points to content. The Block identity binds that content to a verifiable derivation structure.

## 2. Verified derivation graphs

Chains of Blocks form verified derivation graphs.

A source document can be a Block. A summary can be a Block derived from the source. A synthesis can be a Block derived from multiple summaries. A review can be a Block derived from the synthesis. A final recommendation can be a Block derived from the synthesis and review.

When those Block-linked artifacts are stored through IPFS, the result is a portable graph of content-addressed artifacts with verifiable lineage.

## 3. Machine-readable context for agents and applications

ALX’s long-term value is not only artifact verification. Verified derivation graphs become machine-readable context that downstream systems can inspect and compose.

IPFS can serve as the retrieval layer for that context.

An agent can retrieve an artifact package by CID, validate its Block identity, inspect parent references, and decide how to use the artifact in a downstream workflow. This pattern supports agentic systems, RAG pipelines, evaluation workflows, compliance systems, research tooling, and enterprise AI governance.

## 4. Local verification with decentralized retrieval

ALX verification remains local. The verifier recomputes the Block hash. IPFS supplies retrieval, not authority.

That separation is important.

- IPFS makes the artifact available.
- ALX verifies the artifact structure.
- Applications interpret the artifact meaning.

This creates a clean layered model:

| Layer | Responsibility |
|---|---|
| **IPFS** | Content-addressed retrieval |
| **ALX** | Deterministic artifact identity and lineage verification |
| **Applications** | Meaning, policy, access control, and domain judgment |

## 5. A reusable integration pattern for AI infrastructure

The funded work will produce open-source tooling and documentation that other projects can reuse when storing structured AI artifacts on IPFS.

The pattern is broadly useful:

```text
CID fetch → artifact parse → Block validation → parent traversal → verification receipt
```

Any AI-native protocol, agent platform, research system, or enterprise workflow that wants to store verifiable artifacts on IPFS can adopt this pattern.

---

# Proposed Work

This grant funds the ALX/IPFS artifact layer.

The work is scoped around making Blocks and Block-linked artifacts easier to store, retrieve, verify, and compose through IPFS.

## Workstream 1: IPFS Block Storage Adapter

Build and document an IPFS storage adapter for ALX Blocks and associated artifact packages.

The adapter will support:

- storing Block content or referenced artifact packages on IPFS
- returning CIDs for stored artifacts
- preserving the mapping between Block identity and IPFS content address
- retrieving artifact content by CID
- validating retrieved content against the expected Block structure
- supporting local verification after retrieval

**Deliverable:**
A reusable IPFS adapter that lets developers store and retrieve ALX Block content through IPFS while preserving deterministic Block verification.

## Workstream 2: CID-Bound Artifact Package Format

Define and document a recommended artifact package structure for ALX/IPFS workflows.

The package should support:

- primary artifact payload
- Block metadata
- parent references
- verification receipt
- optional context attachments
- optional attestations
- source references
- manifest file
- integrity metadata

Example package:

```text
alx-artifact/
block.json
content.json
manifest.json
verification.json
parents.json
attachments/
evidence/
attestations/
```

The goal is not to make this package format part of core ALX validity. The goal is to provide a practical, reusable convention for storing machine-readable ALX artifacts on IPFS.

**Deliverable:**
A documented ALX/IPFS artifact package convention that makes Blocks easier to retrieve, inspect, verify, and compose.

## Workstream 3: Independent Verification CLI

Build a CLI that allows any developer, reviewer, agent, or grant evaluator to verify an ALX/IPFS artifact from a clean state.

The CLI should support:

- fetch artifact package by CID
- parse Block payload
- recompute content hash
- recompute Block hash
- confirm parent references
- validate artifact package integrity
- produce a verification receipt
- fail on tampered content
- run without trusting Xandr Labs or a hosted service

Example command:

```bash
alx ipfs verify
```

Expected result:

```text
Artifact retrieved
Block parsed
Content hash verified
Parent references normalized
Block hash recomputed
Structural validity confirmed
Verification receipt generated
```

**Deliverable:**
An open-source verification CLI that demonstrates independent ALX/IPFS verification from a clean environment.

## Workstream 4: Multi-Provider Pinning and Retrieval Validation

Develop and document a multi-provider pinning strategy for ALX/IPFS artifacts.

This workstream will include:

- pinning artifacts across multiple providers
- testing retrieval across gateways
- detecting provider failure
- validating fallback retrieval
- documenting provider-agnostic migration
- producing an operator runbook

The goal is to ensure that ALX artifacts stored through IPFS remain retrievable even when a single gateway or pinning provider fails.

**Deliverable:**
A multi-provider pinning and retrieval validation workflow with documented failover behavior.

## Workstream 5: Reference Agent Workflow Demo

Build a reference demo showing how an AI agent or application can create, store, retrieve, and verify ALX artifacts through IPFS.

**Demo flow:**

1. User or agent produces a meaningful artifact.
2. Application creates an ALX Block.
3. Block content or artifact package is stored through IPFS.
4. CID is returned and associated with the Block.
5. Downstream agent retrieves the artifact by CID.
6. Agent validates the Block locally.
7. Agent inspects parent lineage.
8. Agent produces a downstream Block referencing the verified parent.

**Deliverable:**
A working demo showing ALX Blocks stored on IPFS, retrieved by CID, verified locally, and composed into a downstream verified derivation graph.

---

# Development Roadmap

## Month 1 — IPFS Adapter and Artifact Package Specification

The first month establishes the core integration layer.

### Work includes

- implement initial IPFS storage adapter
- define ALX/IPFS artifact package structure
- document Block-to-CID mapping
- create example artifact packages
- validate local verification after retrieval
- publish developer documentation

### Deliverables

- IPFS adapter
- artifact package specification
- example ALX/IPFS artifacts
- basic retrieval and validation flow
- documentation for developers

### Success criteria

A developer can create a Block, store its content or package on IPFS, retrieve it by CID, and verify the Block locally.

## Month 2 — Verification CLI and Retrieval Validation

The second month makes the integration independently auditable.

### Work includes

- build `alx ipfs verify ` command
- implement CID fetch and Block validation
- generate verification receipts
- add tamper test vectors
- validate clean-room verification from a fresh environment
- document verification behavior

### Deliverables

- verification CLI
- verification receipt format
- tamper validation tests
- clean-room verification instructions
- public documentation

### Success criteria

Any independent reviewer can fetch an ALX/IPFS artifact by CID and verify its Block identity without trusting Xandr Labs or a hosted service.

## Month 3 — Multi-Provider Pinning, Agent Demo, and Operator Runbook

The third month completes the production-readiness layer.

### Work includes

- configure multi-provider pinning
- validate retrieval across providers
- simulate provider failure
- document failover behavior
- build reference agent workflow demo
- publish operator runbook
- produce final grant report

### Deliverables

- multi-provider pinning setup
- retrieval validation harness
- agent workflow demo
- operator runbook
- final technical writeup
- reusable integration guide for other IPFS projects

### Success criteria

- ALX/IPFS artifacts remain retrievable across provider failure.
- A downstream agent can retrieve and verify a parent Block from IPFS before creating a derived Block.
- Developers can reproduce the full workflow from public documentation.

---

# Final Deliverables

## 1. IPFS Storage Adapter

A reusable adapter for storing and retrieving ALX Block content or artifact packages through IPFS.

## 2. ALX/IPFS Artifact Package Specification

A documented package convention for representing Block-linked artifacts, supporting content, metadata, verification receipts, parent references, attachments, and evidence.

## 3. Independent Verification CLI

An open-source CLI that fetches an artifact by CID, recomputes Block identity, verifies lineage structure, and produces a verification receipt.

## 4. Multi-Provider Pinning Workflow

A documented redundancy workflow for pinning ALX/IPFS artifacts across multiple providers and validating retrieval under provider failure.

## 5. Reference Agent Workflow Demo

A working demo showing an agent creating, storing, retrieving, verifying, and deriving Blocks using IPFS as the artifact retrieval layer.

## 6. Operator Runbook

A practical guide covering setup, pinning, verification, retrieval validation, failure handling, and clean-room reproduction.

## 7. Public Technical Writeup

A grant-completion writeup explaining how ALX and IPFS compose, how developers can adopt the integration, and how the pattern benefits AI-native artifact infrastructure.

---

# Strengthening the IPFS Ecosystem

This project strengthens IPFS by giving it a new class of high-value AI-native artifacts.

## Content addressing for verified AI artifacts

ALX makes AI outputs identifiable and lineage-aware. IPFS makes their content and supporting evidence retrievable by content address. Together, they create portable artifacts that can move across systems without losing verification structure.

## Reusable verification tooling

The verification CLI and package specification provide a reusable public-good pattern for any project that wants to store structured AI artifacts on IPFS.

## Machine-readable artifact packages

ALX/IPFS artifacts are designed for machines and applications, not only human browsing. Agents can retrieve artifacts, validate structure, inspect lineage, and use verified context in downstream workflows.

## Durable context for AI workflows

ALX Blocks and verified derivation graphs support machine-readable context. IPFS can preserve that context across applications, teams, tools, and time.

## Additive ecosystem design

ALX is storage-neutral by design. IPFS is not forced into the protocol, and the protocol is not dependent on IPFS. The integration is valuable because the two systems compose cleanly:

- ALX provides artifact verification.
- IPFS provides content-addressed availability.
- Together, they support portable AI artifact infrastructure.

---

# Impact

The funded work will make ALX/IPFS integration usable by developers building:

- agent workflows
- RAG systems
- model evaluation pipelines
- research tooling
- compliance systems
- enterprise AI governance
- source-grounded generation
- audit trails
- verification receipts
- context-aware applications

The short-term impact is a working open-source integration: developers can create Blocks, store artifacts on IPFS, retrieve them by CID, and verify them locally.

The medium-term impact is a reusable infrastructure pattern: any AI-native project can adopt ALX/IPFS artifact packages to make its outputs more portable and verifiable.

The long-term impact is a stronger decentralized knowledge layer: AI artifacts become durable, content-addressed, lineage-aware objects that can be reused across systems instead of disappearing inside application logs or vendor-specific storage.

---

# Data Onboarding

ALX onboards a category of data that is becoming increasingly important: **verified AI artifacts**.

These include:

- source-grounded summaries
- research findings
- model evaluations
- benchmark results
- compliance evidence
- workflow decisions
- human reviews
- policy checks
- agent handoffs
- RAG outputs
- creative artifacts
- software architecture decisions
- verified context records

These artifacts are not merely files. They are structured outputs with identity, lineage, and verification requirements.

An ALX/IPFS artifact package can include:

| File | Purpose |
|---|---|
| `block.json` | Canonical Block representation |
| `content.json` | Primary artifact payload |
| `parents.json` | Parent Block references |
| `manifest.json` | Package inventory |
| `verification.json` | Verification receipt |
| `metadata.json` | Descriptive metadata |
| `attachments/` | Optional context attachments |
| `attestations/` | Optional signed claims |
| `evidence/` | Supporting evidence, logs, or test outputs |

IPFS stores the artifact package.

ALX verifies the structure.

Applications interpret the meaning.

This separation creates a practical pattern for storing AI-native artifacts in decentralized infrastructure.

---

# Example Workflow

A compliance team uses an AI workflow to review whether a customer record satisfies a policy.

1. The policy document is sealed as **Block A**.
2. The customer record is sealed as **Block B**.
3. A review agent produces a compliance assessment from Blocks A and B, creating **Block C**.
4. Block C’s artifact package is stored on IPFS.
5. The resulting CID is associated with the Block.
6. A human reviewer signs an attestation on Block C.
7. A final recommendation references Block C as its parent, creating **Block D**.
8. An auditor later retrieves Block C by CID and verifies its structure locally.

The auditor does not need the original agent framework, vendor platform, or hosted service to confirm the structure of the workflow.

- The Block provides the verifiable derivation structure.
- IPFS provides content-addressed retrieval.
- The application provides policy interpretation.

---

# Maintenance and Upgrade Plan

The ALX/IPFS artifact layer will be provider-agnostic.

If one pinning provider changes APIs, becomes unavailable, or is deprecated, artifacts can be replicated through another provider while preserving Block identity. Since ALX verification depends on deterministic content and parent hashes, storage migration does not change protocol validity.

## Ongoing maintenance will include

- updating IPFS adapter dependencies
- monitoring gateway compatibility
- improving retrieval validation
- expanding artifact package examples
- updating documentation
- maintaining verification CLI compatibility
- extending test coverage as usage grows

Xandr Labs will maintain the integration as part of the ALX ecosystem. The protocol itself remains open, MIT-licensed, and independently implementable.

---

# Team

Xandr Labs is an AI product lab building systems and infrastructure that make intelligent technology more useful, understandable, and trusted.

ALX Protocol is Xandr Labs’ first foundational product. It establishes the verification layer beneath context-aware intelligent systems by giving AI-generated and machine-produced artifacts deterministic identity, verifiable lineage, and traceable attribution.

The ALX ecosystem includes:

- open protocol specification
- reference implementations
- conformance tooling
- SDKs
- agent middleware
- storage adapters
- attestation adapters
- CLI tooling
- managed verification infrastructure
- future context-aware products

The IPFS grant supports the storage and retrieval layer that makes ALX artifacts more portable across decentralized infrastructure.

---

# Relevant Experience

The ALX whitepaper describes the protocol as an open verification standard with deterministic identity, verifiable lineage, and portable derivation evidence. The protocol is designed so Blocks can be verified locally and composed with storage systems, attestations, chains, and applications without making any one of those systems part of core validity.

The existing ALX materials also identify an IPFS adapter as part of the broader component set for content-addressed Block storage and hash mapping.

This grant extends that foundation into a production-grade, independently verifiable IPFS artifact layer.

---

# Ecosystem Positioning

ALX is additive to the IPFS ecosystem and adjacent decentralized infrastructure.

| Ecosystem layer | What it contributes | How ALX composes |
|---|---|---|
| IPFS | Content-addressed storage and retrieval | Stores Block-linked artifact packages and supporting evidence |
| Filecoin | Long-term decentralized storage markets | Can support durable retention for high-value ALX artifacts |
| Attestation systems | Signed claims | Can sign claims about specific Block identities |
| Blockchains | Shared commitments and timestamping | Can anchor checkpoints or registries for public verification |
| Agent frameworks | Multi-step AI workflows | Can wrap meaningful handoffs in Blocks |
| RAG systems | Source-grounded generation | Can represent approved sources and outputs as Blocks |

ALX does not replace these systems. It gives them a shared artifact primitive to coordinate around.

For IPFS specifically, ALX makes AI artifacts more useful as stored objects because each artifact can carry identity, lineage, and verification semantics.

---

# Success Means

Starting from a clean environment, a developer or independent reviewer can:

1. Create an ALX Block.
2. Store the Block-linked artifact package on IPFS.
3. Retrieve the artifact by CID.
4. Recompute the Block identity locally.
5. Verify content integrity and parent lineage.
6. Produce a verification receipt.
7. Use the verified artifact as a parent for a downstream Block.
8. Confirm that the resulting derivation graph remains inspectable and portable.

Success is not merely that files are uploaded to IPFS.

Success is that AI artifacts become independently retrievable, structurally verifiable, and composable across systems.

---

# Budget Request

**Total requested: $25,000**

The request funds five workstreams scoped to the ALX/IPFS artifact layer:

| Workstream | Allocation |
|---|---:|
| IPFS storage adapter | $5,000 |
| Artifact package specification | $4,000 |
| Verification CLI | $6,000 |
| Multi-provider pinning and retrieval validation | $5,000 |
| Reference demo, documentation, and operator runbook | $5,000 |

This funding is scoped to public-good infrastructure for ALX/IPFS interoperability. It does not fund XAN, tokenization, hosted commercial services, or unrelated product development.

---

# Why Fund This Now

AI artifacts are becoming economically and operationally consequential. They need durable identity, verifiable lineage, and portable derivation evidence.

IPFS is a natural home for the content and context behind those artifacts.

ALX gives IPFS a practical AI-native artifact model: Blocks and verified derivation graphs. The grant funds the tooling that makes this model usable by developers, agents, reviewers, and downstream systems.

The work creates reusable public infrastructure:

- an IPFS adapter
- an artifact package convention
- independent verification CLI
- multi-provider retrieval validation
- agent workflow demo
- operator documentation

This is the kind of integration that helps IPFS become part of the AI infrastructure stack: not only a place to store files, but a place where verifiable AI artifacts can live, be retrieved, be checked, and be reused across systems.

---

# Closing Statement

ALX Protocol defines a verification layer for artifacts that matter.

IPFS gives those artifacts a content-addressed availability layer.

Together, they create a practical foundation for verifiable AI artifact infrastructure: outputs that can be stored, retrieved, verified, traced, and composed across systems.

This grant funds the work that makes that foundation usable in practice.