The protocol forintelligent systems
Give every human or machine output portable identity, declared lineage, and independent verification.
npm i @alx-protocol/sdkHow ALX Works
Every Block contains content and declares its relationships to prior Blocks.
The contentHash identifies the canonicalized content. The blockHash identifies the canonicalized content together with the Block’s declared parents.
Changing the content changes both identities. Changing only the declared parents changes the blockHash while the contentHash remains the same.
Anyone holding the Block can independently recompute and validate both identities using the protocol rules. When the referenced parent Blocks are available, those relationships can be followed to verify lineage and trace the derivation graph.
// Parent Block — Get Started{"protocolVersion": "1","content": {"title": "Get Started","url": "/documentation/ guides"},"parentHashes": [],"contentHash": "0x18a455…95e925","blockHash": "0xf4010d…f75a71"}
// Child Block — Quick Start{"protocolVersion": "1","content": {"title": "Quick Start","url": "https:// alxprotocol.com/ documentation/ guides/ quick-start","description": "Create, verify, and compose your first ALX Blocks."},"parentHashes": ["0xf4010d…f75a71"],"contentHash": "0x0d628d…f94b45","blockHash": "0x63c11f…69cd8f"}
Build with ALX
Create Blocks
Create deterministic Blocks from JSON-compatible content.
Declare Lineage
Record direct parent relationships between related Blocks.
Verify Blocks
Recompute Block identities from public protocol rules.
Build Derivation Graphs
Accumulate declared relationships into a connected derivation graph.
Traverse Context
Follow the graph to retrieve the prior work a task depends on.
Build Across Systems
Use the same Block identities and graph structure across independent agents and applications.
ALX AI Workflows
AI Provider
AI Provider + ALX
AI Provider
Outputs and context are often bound to the application, session, or workflow that created them.
AI Provider + ALX
Outputs are recorded as portable ALX Blocks with deterministic identities.
AI Provider
An output may exist as data without a consistent identity across systems.
AI Provider + ALX
Each Block has a deterministic identity derived from its content and declared relationships.
AI Provider
When outputs move between agents or applications, their prior context and origin may not move with them.
AI Provider + ALX
Blocks carry explicit references to prior Blocks, preserving declared lineage across participating systems.
AI Provider
As AI-generated work is reused and transformed, determining what a result was derived from can require application-specific records.
AI Provider + ALX
Declared Block relationships create provenance that records what available prior work a new artifact builds upon.
AI Provider
Stored outputs may be difficult for another system to independently check against the original record.
AI Provider + ALX
Block identity can be independently verified and Block structure and relationships validated using the same protocol rules.
AI Provider
Tracing a result through multiple agents, sessions, or workflows can depend on fragmented application history.
AI Provider + ALX
Block relationships form a traversable derivation graph for tracing outputs through their available lineage.
AI Provider
Context and history may become fragmented across applications, sessions, and integrations.
AI Provider + ALX
Conforming systems can identify, validate, verify, and traverse the same available ALX records without changing the underlying AI provider.
Traceable Context
Preserve the context behind each output as work moves between people, agents, models, tools, and organizations.
ALX Blocks carry deterministic identities and declared relationships that applications and AI systems can verify, follow, and use to build derivation graphs across multi-step workflows.
Compose Blocks into a Graph- Block Graph
- Agent
- Tool
- Human review
- Application
Use Cases
- AI & Agent WorkflowsCarry verifiable context, lineage, and prior work across agents and applications.
- Software ProvenanceTrace releases back to their declared inputs and independently verify the recorded build lineage.
- Research & DataRecord how datasets, transformations, and intermediate results contribute to a final output.
- Compliance & Audit RecordsEstablish deterministic record identity and trace declared relationships without requiring a shared database.
Around the Protocol
Explore projects, infrastructure, and resources that extend and support the ALX ecosystem.
- Start Building, ALX Protocol
ALX Protocol
Create and verify Blocks with deterministic identity and declared lineage.
- View Commitments, Blockchain Commitments
Blockchain Commitments
Publish commitment evidence without changing Block identity.
- Visit XNDR Network, XNDR.network (opens in a new tab)
XNDR.network
Develop shared network services around ALX Blocks.
- View Release Information, Release Information
Release Information
ALX components version independently. Review the current specification, protocol, package, Solidity, and deployment indicators.
- Specification
- 2.0
- Protocol Version
- 1.1
- TypeScript
- 1.0.1
- Python
- 1.0.1
- Rust
- 1.0.1
- Solidity
- 0.8.28
- Contract Deployment
- None
About Us
Open Development
ALX Protocol is developed in the open through published specifications, conformance materials, reference implementations, and developer tooling. These resources are available for public review, implementation, and contribution.
The ALX Foundation stewards ALX Protocol as an open standard, maintaining the normative protocol sources, canonical conformance materials, governance processes, and protocol releases.
ALX Labs is the founding contributor to ALX Protocol and develops implementations, developer tooling, and supporting infrastructure around the standard.
Published specifications, source code, conformance materials, and release history allow developers to inspect how ALX works before adopting it.
ALX remains openly implementable. Developers and organizations can build independent implementations, extensions, services, and infrastructure that conform to the protocol.
What is an ALX Block?
A digital content object with deterministic identity and declared parent relationships.
Why use ALX Protocol?
ALX gives applications a shared structure for identifying digital artifacts, declaring direct inputs, and independently verifying protocol results across workflows.
Does ALX store content?
ALX defines how Blocks are structured and identified. Implementations can use databases, object storage, decentralized storage, or other systems to store and make Block data available.
Do I need an account or a hosted service to use ALX?
No. Once a package is installed, Blocks are created and verified locally, with no account, API key, or network connection. ALX does not require a hosted service or vendor API.
What can an application do with an ALX Block?
Applications and AI systems can retrieve Blocks, verify their identities, inspect declared dependencies, and create new Blocks that reference previous inputs and outputs.
What happens when content or declared lineage changes?
A change to canonicalized content changes its content identity. A change to the content or normalized parent identities changes the resulting Block identity.
What does ALX verify?
ALX supports structural verification of Block identity and declared lineage. Meaning, accuracy, authorship, ownership, quality, permissions, and other trust decisions remain with applications and applicable external systems.
Do Blocks created in one language verify in another?
Yes. The JavaScript, Python, and Rust packages apply the same protocol rules and are checked against the same conformance vectors before release, so a Block created in one verifies in the others. The specification and vectors, not any one package, define protocol behavior.
Every Block can become a building block for what comes next.
The next agent or application can receive the output with verifiable context: its deterministic identity, declared dependencies, and lineage to prior work.
ALX-aware systems can traverse available Blocks to trace provenance, verify identities and declared relationships, retrieve prior work, and assemble structured context for what comes next.