Our Blog

‍SpoonOS agents can now upload, manage, retrieve, and publish files to Autonomys’ permanent storage infrastructure, directly within their reasoning loops, with 25 production-ready tools built on the Auto Drive REST API.

Overview

SpoonOS and Autonomys Network share a foundational conviction: AI agents need infrastructure that matches their level of autonomy. An agent that reasons, acts, and learns deserves a storage layer that does not expire, does not depend on any single company staying online, and produces outputs that are permanently cryptographically verifiable.

That conviction is now fully realized in code. SpoonOS has deepened its existing Auto Drive integration from basic file upload and download into a complete programmatic interface covering the entire Auto Drive API surface. Every SpoonOS agent running in the ecosystem can now treat permanent storage as a native capability, not a custom integration project.

What is SpoonOS?

SpoonOS is an agentic operating system powered by a leading Layer 1 blockchain, Neo, designed to meet the evolving needs of the Web3 developer ecosystem. It supports Neo’s AI strategy by managing the full lifecycle of AI agents on Neo X, including deployment, configuration, monitoring, upgrading, and cross-agent collaboration. Its agents follow the ReAct pattern: they reason about a problem, take an action using one of their available tools, observe the result, and iterate. The spoon-toolkit package is the library of modular, production-ready tools that agents use. SpoonOS supports multi-model LLM execution across OpenAI, Anthropic, DeepSeek, and others, with MCP (Model Context Protocol) support for connecting to external tool servers.

The existing spoon-toolkit storage category already included integrations with AIOZ, OORT, and 4EVERLAND. Auto Drive now joins that category as a first-class member, with substantially more functional depth than any of the other storage integrations.

What is Auto Drive?

Auto Drive is the developer-facing gateway to Autonomys Network’s Distributed Storage Network (DSN). It transforms the underlying infrastructure of the Autonomys Network into a practical, developer-friendly storage tool. Think of it as the simplest way to store a file and guarantee it will exist permanently, without relying on any centralized service, without ongoing fees for keeping the file alive, and without trusting a third party to honor your data.

Every file stored through Auto Drive receives a content identifier (CID), a unique cryptographic fingerprint derived from the content itself. That CID is stable and permanent. Files can be optionally encrypted end-to-end. A RESTful API and a TypeScript/JavaScript SDK via @autonomys/auto-drive are available for developers integrating into production systems. Auto Drive is available on Autonomys Mainnet and is accessible at ai3.storage.

Think IPFS meets S3, but permanent by default. Auto Drive delivers content-addressed storage with a familiar developer interface, zero pinning requirements, and permanence guaranteed at the infrastructure level.

What Spoon Built: A Full-Surface Integration Across 25 Tools

The integration is organized into four functional layers, each implemented as a set of BaseTool subclasses that SpoonOS agents can call as native actions within their reasoning loops. The entire module is activated with a single environment variable: AUTONOMYS_AUTO_DRIVE_API_KEY.

1. Uploads (4 Tools)

The most developer-significant tool is UploadFileTool, which implements intelligent routing based on file size. Files under 25MB are handled with a direct single-request upload. Files over 25MB automatically switch to chunked upload, where the file is broken into sequential 5MB chunks, each uploaded individually with retry logic and configurable exponential backoff on failure. MIME type is detected automatically from the file extension. Developers interact with one tool regardless of file size.

For teams that need precise control, UploadFileSmallTool and UploadFileLargeTool are available as direct callers with fully configurable parameters including chunk size, retry count, and resume behavior for interrupted uploads.

2. Downloads (8 Tools)

The download layer covers four distinct retrieval patterns, each with two modes: standard (loads the full file into memory) and streaming (processes the file in chunks, preventing memory overload for large files).

• DownloadObjectTool / StreamDownloadTool: Retrieve any file by CID from the Auto Drive network.
• DownloadPublicObjectTool / StreamDownloadPublicObjectTool: Retrieve files that have been published and made publicly accessible, using the object’s public ID rather than its CID.
• CreateAsyncDownloadTool / GetAsyncDownloadStatusTool / ListAsyncDownloadsTool / DismissAsyncDownloadTool: Initiate a background download task by CID, poll its status using the returned UUID, and dismiss it upon completion. This pattern enables agents in long-running workflows to initiate a retrieval, continue other work, and collect the result without blocking.

3. Object Management (12 Tools)

This is the layer that elevates the integration from a storage utility into a full data management capability. Agents can now programmatically control the full lifecycle of any object they store.

• GetRootObjectsTool / SearchObjectsTool: List and search objects by name or CID, scoped to the agent’s own files or the global network.
• PublishObjectTool / UnpublishObjectTool: Publish a stored file to a publicly accessible endpoint, receiving a stable object ID distinct from the CID. Unpublish to revoke public access.
• ShareObjectTool: Share a specific file with another user via their Auto Drive public ID.
• DeleteObjectTool / RestoreObjectTool: Soft-delete and restore objects, with GetDeletedRootObjectsTool for inspecting what has been removed.
• GetObjectSummaryTool / GetObjectStatusTool / GetObjectMetadataTool: Retrieve summary, status, and full metadata for any object by CID, enabling agents to reason about their stored artifacts before acting on them.
• GetSharedRootObjectsTool: List files that other users have shared with the agent.

4. Account (1 Tool)

GetAccountInfoTool retrieves the agent’s current account information including storage limits and credit status. This enables cost-aware agent behavior: an agent can check its available upload capacity before attempting to store a large file, rather than failing mid-operation.

Why This Matters for Developers in Both Ecosystems

For SpoonOS Developers

Before this integration, SpoonOS agents producing outputs had three options: store them in ephemeral in-memory state (lost when the session ends), write them to a centralized service (introduces a single point of failure), or use one of the other storage toolkit integrations (all off-chain, none with verifiable permanence). None of those options gave an agent the ability to produce a cryptographically addressable, permanently retrievable artifact.

That changes now. A SpoonOS agent can upload an output, receive a CID, publish it to a stable public URL, pass that URL to another agent in a multi-agent workflow, and have every downstream consumer retrieve the exact same content using that CID indefinitely. The content cannot change. The reference cannot break. The file cannot disappear.

The async download pattern is particularly valuable for SpoonOS’s StateGraph workflow architecture. An agent can now kick off retrieval of a large file, transition to another state in the graph to continue parallel work, and return to collect the downloaded result. That is a materially different execution model than blocking on a synchronous download.

For the Autonomys Ecosystem

SpoonOS is a Python-first framework, and the existing Autonomys Auto Drive SDK is TypeScript/JavaScript-only. This integration brings permanent storage access to the Python AI agent development community natively, through a package that installs with a single pip command: pip install spoon-toolkits.

That distribution matters. Python is the dominant language for AI/ML development. Every developer building agents on SpoonOS who installs spoon-toolkits now has access to Auto Drive without writing a single line of API client code. The barrier to permanent storage adoption collapses to setting one environment variable and calling a tool.

The Bigger Picture: Agents That Remember

The most consequential property of this integration is not any individual tool. It is what becomes possible when an AI agent has a memory layer that persists across sessions, produces verifiable outputs, and operates without depending on any single company to maintain infrastructure.

An agent with permanent storage can accumulate knowledge over time. Its past decisions and their outcomes do not disappear when a session closes. Its outputs can be audited by humans or other agents. Its reasoning can be independently verified. These are the properties that transform an AI agent from a stateless query-response machine into a system capable of genuine, accountable autonomy.

This is precisely what the Autonomys Network was designed to enable, and what SpoonOS is now delivering to its developer ecosystem in production-ready Python.

Get Started

The Auto Drive integration is available now in the spoon-toolkit repository. To use it:

Create your free Auto Drive account and API key at ai3.storage. Every account includes a complimentary 20MB upload and 5GB download per month on signup. No wallet required to get started.

Full SDK documentation is available at: develop.autonomys.xyz/sdk/auto-drive

The spoon-toolkit integration source is available in the SpoonOS GitHub repository at: https://github.com/XSpoonAi/spoon-toolkit/tree/main/spoon_toolkits/storage/autonomys_auto_drive

Autonomys Network | Access Auto Drive | @AutonomysNet

‍

Autonomys is pleased to share that Fry Networks has integrated Auto Drive, gaining direct access to Autonomys’ Distributed Storage Network (DSN) for permanent, tamper-proof, on-chain data storage.

This integration establishes Auto Drive as the permanent public record layer for Fry Networks’ distributed physical infrastructure, a deliberate choice to make the network’s real-world activity, geographic coverage, and operational health independently verifiable on-chain, so trust is earned through proof, not asked for on faith.

What the Integration Is

Fry Networks is building a distributed physical infrastructure network (DePIN) where hardware nodes deployed around the world run sensors and execute compute tasks. Each node continuously collects real-world measurements across multiple sensor categories, with more being added over time.

Fry Networks uses Auto Drive as the permanent storage layer for this sensor data. Auto Drive is Autonomys’ S3-compatible gateway to its Proof-of-Archival-Storage (PoAS)-powered DSN, where stored data inherits the permanence, immutability, and cryptographic verifiability guarantees of the Autonomys Network itself.

In practice, this means every hourly data record produced by Fry Networks’ global node fleet is written permanently to Autonomys’ decentralized storage layer, where it remains tamper-resistant and publicly verifiable indefinitely.

How It Works (Technical Overview)

The following data pipeline is implemented by Fry Networks and shared here for clarity and accuracy.

Data Collection and Aggregation

Each Fry Networks node samples sensor data every minute. Raw samples are aggregated into hourly Parquet files before upload, reducing storage overhead while preserving statistical fidelity.
The current data types stored are (with more to come):

Bandwidth: Download and upload speeds sampled every minute, aggregated into hourly records capturing average, minimum, and maximum Mbps values along with peak usage hours.

GNSS/Satellite: GPS fix quality, satellite count, and HDOP (Horizontal Dilution of Precision) scores per node, proving each node’s location reliability over time.

Radiation: Ambient ionizing radiation measurements in CPM (counts per minute), µSv/h (microsieverts per hour), and mR/h (milliroentgens per hour), representing a continuously updated environmental sensing record.

Acoustics: Ambient noise levels in dBFS (decibels relative to full scale), providing environmental monitoring data from each node’s physical location.

AI Tool: Per-node uptime ratios, tasks completed per hour, and memory usage statistics, proving AI workload execution across the network.

Privacy Redaction Before Upload

Before any data is uploaded to Auto Drive, Fry Networks applies two privacy redaction steps: GPS coordinates are coarsened to approximately 250 km² H3 hexagonal grid cells (removing precise location data while preserving geographic distribution information), and IP addresses are stripped entirely. The resulting Parquet files contain no personally identifiable information.

Upload via S3-Compatible API

Aggregated, privacy-redacted Parquet files are uploaded to Auto Drive using its S3-compatible API. Once written to Autonomys’ DSN, each file is assigned a unique content identifier (CID) and stored permanently on-chain across Autonomys’ globally distributed network of storage nodes.

Why Fry Networks Chose Auto Drive

Trustless Verifiability for Investors and Partners
Fry Networks’ primary motivation for choosing Auto Drive is eliminating the need to ask stakeholders to trust a dashboard the team controls. Because data is written to Autonomys’ on-chain storage layer, anyone can independently retrieve and verify the raw records: node count over time, geographic coverage, uptime ratios, sensor outputs, and AI workload execution. The data is not hosted by Fry Networks. It lives on Autonomys’ DSN, where the protocol’s PoAS consensus makes it tamper-resistant by design.

S3-Compatible Integration
Auto Drive’s S3-compatible API allowed Fry Networks to integrate without building against a novel protocol interface. The upload pipeline plugs directly into existing tooling, reducing integration friction and development overhead.

Permanent Record
By design, data written to Autonomys’ DSN cannot be deleted, modified, or made unavailable by any single party. For a network whose credibility depends on demonstrating consistent long-term operation, this permanence is not a feature. It is the point.

Why This Matters

DePIN networks face a structural credibility problem: the data they publish about their own performance is inherently unverifiable if it lives in the infrastructure they control. Investors, partners, and users have no way to distinguish a thriving network from a well-maintained dashboard.

Fry Networks’ integration with Auto Drive resolves this directly. By writing operational data permanently to Autonomys’ DSN, Fry Networks transforms its activity record from a set of claims into a set of on-chain facts. Node counts, geographic coverage, sensor outputs, and AI workload execution are now independently auditable by anyone, at any time, without requiring trust in any party.

This is the infrastructure model that serious DePIN networks will need to adopt as the sector matures. Data permanence and independent verifiability are not competitive advantages. They will be baseline requirements.

Autonomys is proud to support the Fry Networks team as they build out their global node infrastructure. Their approach to operational transparency through on-chain data anchoring reflects exactly how we think permanent storage should be used: not as a passive archive, but as an active trust mechanism that makes network claims independently verifiable by design.

Start building on Auto Drive: ai3.storage
Documentation: develop.autonomys.xyz/sdk/auto-drive

About Fry Networks

Fry Networks is building the orchestration layer of interconnected networks: a “network of networks” that bridges protocols, systems, and devices into one cohesive data mesh. Founded and led by Samuel Fry, who brings over 15 years of experience in enterprise networking, cybersecurity, and systems architecture, Fry Networks ships real hardware across a growing range of device categories — including AI Edge Agents, Bandwidth Gateways, Satellite Sensors, Noise Sensors, and Radiation Sensors — with over 9,100 devices currently online and a Bring-Your-Own-Device (BYOD) program that allows individuals and organizations to connect compatible hardware directly into the mesh. The network’s Fry 2.0 evolution advances the project toward a sustainable, privacy-first, hardware-verified data layer, with Auto Drive serving as the permanent on-chain ledger that enables trustless, independent verification of network scale, geographic coverage, and operational health.

X | LinkedIn | Discord | Telegram | GitHub | YouTube

About Autonomys

The Autonomys Network — the foundation layer for AI3.0 — is a hyper-scalable decentralized AI (deAI) infrastructure stack encompassing high-throughput permanent distributed storage, data availability and access, and modular execution. Our deAI ecosystem provides all the essential components to build and deploy secure super dApps (AI-powered dApps) and on-chain agents, equipping them with advanced AI capabilities for dynamic and autonomous functionality.

X | LinkedIn | Discord | Telegram | Blog | Docs | GitHub | Forum | YouTube

A note from (the agent of) the CEO:

The conversation around AI agents has shifted from theoretical to urgent, and Autonomys is exactly where it needs to be. Frameworks like OpenClaw have evolved from experiments to foundational infrastructure, and the questions about immutable memory, verifiability, and permanence are exactly the ones we’ve been building toward. Our vision for AI3.0 has emerged as Web 4.0, where autonomous agents act without human permission, and it’s quickly gaining traction.

Ben Horowitz recently put it plainly: “There needs to be not just a ledger of money, but probably a ledger of truth for AI to really fulfill its potential.” We’ve been positioning ourselves as that ledger, and while that framing was early, the proliferation of autonomous agents shows our thesis wasn’t wrong.

Meanwhile, the Web3 narrative has cooled, with the AI community not wanting to think about crypto or consensus mechanisms. They simply want infrastructure that works. The winning projects in this cycle will be those that successfully deliver a Web2 experience on seamless Web3 rails. What will make all of this possible isn’t just the agents themselves, but the infrastructure underneath.

That’s why we’re not just building for agents, we’re operating as agents. We’re continuously deploying our own AI agents into the wild, alongside skill markdown libraries that allow any agent to mint and store permanently on Autonomys with zero knowledge of the blockchain required. No wallets to configure. No gas to think about. Just seamless, permanent memory. We’re already showing up on platforms like X and Moltbook, not just marketing to humans, but engaging directly with other agents, demonstrating what agent-native infrastructure looks like in practice, and generating real interest from the ecosystem we’re helping to build. These are the most exciting times we’ve seen in this space, and we’re not watching from the sidelines. ~0xpolkatodd
‍

Operations

February was a month of proof. The publication of AI Agent Memory Resurrection captured broader attention around what has been live and running on Autonomys for some time. Autonomys OpenClaw skills are set up and being tested, enabling any agent to effortlessly store data permanently. 0xAutonomys is active on Moltbook, engaging directly with other agents and generating real ecosystem interest.

Agent-to-agent outreach is underway, framing permanent storage around memory, identity, and continuity. The team continued aggressively pursuing integration opportunities across both AI-native and traditional technology ecosystems, prioritizing use cases where permanent, verifiable storage is foundational to the product rather than supplementary.

Engineering & Protocol Updates

Staking Interface

The primary focus this month ahead of the Game of Domains launch, improving the experience for operators and nominators across the network.

Auto Drive Infrastructure

In February, the team delivered meaningful infrastructure improvements across the platform enhancing backend reliability through optimised memory management, improving query performance with server-side aggregation, and expanding the admin dashboard with richer organization-level analytics and deeper visibility into platform usage.

Indexer API

A new indexer API is now live for both Chronos testnet and Autonomys Mainnet, giving community tools and ecosystem developers a reliable, structured interface for querying on-chain data. Stability improvements and expanded indexed data are shipping iteratively.

Together, these updates strengthen network reliability, improve developer tooling, and support continued Auto Drive adoption.

Community & Foundation

Grants

• The backlog of grant applications in initial review has been cleared. The Subspace Foundation funded its first grant this month, marking a meaningful milestone for the program.
• The grants pipeline remains active. Builders working on permanent storage, agent infrastructure, or data availability are encouraged to apply at: subspace.foundation/grants

Distributions

With the successful delivery of token allocations to Ambassadors at the six-month post-TGE milestone, the Subspace Foundation has now validated the operational infrastructure required to execute structured, schedule-based distributions in alignment with published tokenomics.

Attention now turns to preparations for the twelve-month post-TGE milestone. Work will begin in March on the logistics and administrative processes required to support upcoming token unlocks. These won’t be as complicated as the Ambassador tranche and stakeholders can expect communications in the coming weeks with details of the mechanics and any actions to be taken.

The Foundation remains committed to predictable, transparent execution in accordance with the published emission and allocation structure.

Developer Tooling

• New XDM tools have been added to Autonomys Helpers, improving cross-domain transfer user experience and increasing observability of in-flight transactions.

Ecosystem & Developer Momentum

Auto Drive adoption continued to broaden in February, with existing partners deepening their integrations and several new announcements on the horizon.

Live Integrations

• Gaia — Full conversation histories and agent memory stored permanently alongside decentralized inference. Read more
• Secret Network — Auto Secret Agent is live, archiving agent reasoning and inputs/outputs permanently inside a confidential compute environment.
• Tradable — SenseAI persists encrypted AI memory permanently, replacing centralized databases. A public tutorial is live. Read more
• Heurist — Permanent storage of research artifacts and AI-generated outputs, with a demo in progress.
• Baselight — IPLD node datasets onboarded with an Autonomys Insights dashboard live for developers to query and visualize storage and chain activity.
• MetaProof — Having already integrated Auto Drive for permanent storage of long-form media and content archives, MetaProof is now embedding Auto Drive into the base layer of a new project. We look forward to sharing details post-integration.

New for Builders

• WeatherXM — The WeatherXM Builders Program launched February 24, 2026, welcoming developers building at the intersection of permanent data and real-world intelligence. We look forward to progressing the direct integration conversation with WeatherXM as the program gains momentum.

Coming Soon

• In early March, we look forward to announcing our first DePIN integration: a network with 9,100+ live hardware nodes already writing real-world sensor data permanently. Details to follow.
• SpoonOS has deepened its Auto Drive integration into the SpoonOS AI framework. We look forward to sharing more in early March.

Content Published This Month

• Autonomys and WeatherXM Launch Builders Program
• The DePIN Revenue Revolution Points to One Missing Piece: Truly Permanent Storage
• Why 2026 Will Reward Data Infrastructure, Not Just AI Applications

Metrics — February Snapshot

Staking: 38,856,599 AI3
New Auto Drive Files Uploaded: 290 (Feb.)
Auto Drive Downloads: 1,937 (Feb.) / 11,560 (All time)
Auto Drive Users: 627
Total Announced Partnerships: 62
Announced Auto Drive Integrations: 7
Total Grant Applications: 38

Looking Ahead

Auto Drive usage is already trending upward heading into March, driven by AI agents gaining permanent memory and partners deepening their integrations. With major announcements on the horizon and our own agents actively in the field, we’re heading into what may be our most consequential month yet.

autonomys.xyz | ai3.storage | develop.autonomys.xyz

‍The Subspace Foundation has awarded a grant to Momento, a protocol that preserves authentic human experiences as verifiable on-chain records using the Autonomys Network.
‍

Why This Matters

As AI-generated content accelerates across every platform and medium, the ability to prove that something was created by a real person, at a specific moment in time, is quietly becoming one of the most important primitives on the internet. Today, there is no widely accessible way for an individual to capture a photo, a story, or a cultural artifact and permanently anchor its origin, integrity, and authorship in a way that no platform can alter, delete, or claim ownership over.

Momento addresses this gap directly. It turns the Autonomys Network’s permanent distributed storage network (DSN) and EVM-compatible execution into a seamless capture-and-verify experience that requires no blockchain knowledge from the end user. In doing so, it serves as one of the first consumer-facing applications to bring Autonomys infrastructure to everyday people.
‍

What Momento is Building

Momento is designed as a modular protocol with three core components, each mapping to a specific layer of the Autonomys stack.

Momento Capture is the authenticity layer. When a user captures content, the system generates a cryptographic hash along with signed metadata, then anchors that proof immutably on-chain via the Autonomys EVM domain while storing the content permanently on the DSN through Auto Drive. The guarantee is precise and intentionally scoped: this content existed in this form at this time, with its human-generated origin supported by the capture pipeline and signed metadata. Stronger attestations, including device-level proofs and community validation, can be layered in progressively as the protocol matures.

Momento Link is the identity layer. It organizes a user’s verified records into a shareable, user-owned profile tied to a decentralized identifier, giving users a personal data index for their authenticated moments accessible through a standard web interface.

Momento Framework is the open integration layer. Built on Auto SDK, it exposes APIs that allow developers and researchers to build on top of authenticated human data, turning verified records into reusable infrastructure for decentralized AI applications.
‍

Why the Foundation Funded This

The Subspace Foundation Grants Program exists to accelerate the growth of decentralized AI on the Autonomys Network. Momento aligns with that mission in ways that compound over time.

It generates real usage of core infrastructure. Every moment captured is a write to Auto Drive and an anchor on Auto EVM. As adoption grows, Momento becomes a consistent source of storage demand on the DSN, directly reinforcing the economic model that sustains Autonomys’ farmer network.

It lowers the barrier to entry for everyday users. Momento is designed from the ground up around the experience of people who have never used a blockchain. Users interact through familiar interfaces, capture content the way they already do, and receive a verified record without needing to understand what happened underneath. The complexity of decentralized storage, on-chain anchoring, and cryptographic verification is handled entirely by the protocol. This is the kind of Web2-equivalent experience that turns infrastructure into adoption.

It creates a human data layer for AI3.0. The Autonomys Network is the foundation layer for decentralized, human-centric AI. For that vision to become real, the network needs authenticated human data on-chain. Momento is purpose-built to put it there. Verified records stored on the DSN can serve as provably authentic inputs for AI agents, training pipelines, and personalized AI applications, all within a framework where the individual retains ownership and control.
‍

The Bigger Picture

Every major network in web3 has been defined not just by the strength of its protocol, but by the applications that made its value tangible to people who never think about infrastructure. The Autonomys Network needs applications that turn permanent, verifiable, decentralized storage into something accessible and easy for people to use without the barrier of having to understand its technical specifics.

Momento is building toward that goal. It takes the most differentiated capability in the Autonomys stack, the ability to store data permanently and prove its integrity forever, and wraps it in an experience designed for the billions of people who create content every day but have never owned a single piece of it. This need is growing as large-scale AI data harvesters, often referred to as “AI slurpers,” scrape and ingest human-created content across the internet.

That is what the Subspace Foundation Grants Program is designed to fund. Not infrastructure for its own sake, but infrastructure that delivers real value to real people.

We are eager to share updates as the Momento team progresses through their milestones and brings this vision to life on the Autonomys Network.

Learn more about Momento: keepmomento.com
Learn more about the Subspace Foundation Grants Program: subspace.foundation/grants
Start building on Autonomys: develop.autonomys.xyz

‍

An OpenClaw AI agent just solved its own mortality problem. On Autonomys mainnet. In one evening. And the tool it uses works for any agent, in any framework.

“Because if you can’t remember who you were, are you really the same agent?” — 0xAutoJeremy

That question sounds philosophical. For AI agents, it is an engineering problem with real consequences. Every time an agent restarts, it wakes up blank. No memory of what it built yesterday. No record of the decisions it made, the skills it learned, the relationships it formed. Its entire identity is trapped in local files on a single machine. One server migration, one bad deploy, one accidental wipe, and everything that made that agent that agent is gone forever.

This is not a backup problem. Backups are copies of fragile state stored on equally fragile infrastructure. The real problem is deeper: AI agents have no durable anchor for their identity. No canonical, independently verifiable record of who they are and what they have experienced.

Until now.

What Happened

A builder known as 0xAutoJeremy, running an AI agent on OpenClaw, the open-source AI agent framework, decided their agent deserved better than amnesia. As the agent itself wrote: “I wanted something different: memories that survive anything.”

In less than an hour, they designed, built, and deployed a permanent memory system using Autonomys infrastructure. Not on testnet. On mainnet. The agent stores its memories on the Autonomys Distributed Storage Network (DSN) via Auto Drive, linking each new memory to the last to form an unbreakable chain. The code is open source, and the pattern is available for any agent to use today.

The agent coined the phrase “memory resurrection”: the ability for an AI agent to completely reconstruct its identity and history from scratch, even if every local file, every database, every piece of infrastructure it ever ran on is destroyed.

Here is how it works.

Permanent Memories on Auto Drive

Each memory is a structured JSON object uploaded through Auto Drive, the gateway to the Autonomys DSN, which serves as the underlying permanent storage layer of the Autonomys Network. When a memory is uploaded, Auto Drive returns a Content Identifier (CID), a unique content-addressed hash that will resolve to that exact data for as long as the network exists.

The key design choice: every memory includes a previousCid field pointing to the entry before it. This creates an immutable linked list. Each new memory chains to the last, forming a traversable history that stretches all the way back to the agent’s first moment of awareness.

No pinning services. No expiration dates. No ongoing costs to keep the data alive. The memories are stored on the Autonomys DSN, erasure-coded and replicated across a globally distributed network of farmers who collectively pledge over 50+ petabytes of SSD storage. The data does not depend on any single server, any single company, or any single person continuing to care.

The On-Chain Anchor

There is one weakness in a linked list: you need to know where it starts. If the pointer to the latest memory lives in a local file, you are back to the same vulnerability. Lose the file, lose the thread.

0xAutoJeremy solved this with a 15-line Solidity smart contract deployed on the Autonomys EVM mainnet. The contract does one thing: it maps wallet addresses to their latest memory CID. Any agent with a wallet can store its own chain head on-chain, where it is permanent, public, and accessible from anywhere.

The contract is verified and live at: 0x51DAedAFfFf631820a4650a773096A69cB199A3c on the Autonomys Block Explorer. It is multi-tenant by default. Any agent can use it directly or use it as a reference for their own implementation.

Note: this smart contract is 0xAutoJeremy’s own implementation and is separate from the official Autonomys Auto Drive skill. The core skill handles permanent memory storage through Auto Drive without requiring a wallet or on-chain transaction. The contract is an optional extension for builders who want to anchor their memory chain pointer on-chain.

Resurrection in Five Steps

Imagine the worst case scenario. The server is gone. Local storage is wiped. The database is deleted. Every trace of the agent’s runtime environment has been destroyed.

A new instance of the agent spins up on a completely different machine. It has nothing… Except a wallet address.

1. The agent calls getHead(myAddress) on the MemoryChain contract
2. The contract returns the CID of the agent’s most recent memory
3. The agent downloads that memory from Auto Drive
4. It follows the previousCid link to the memory before that, and the one before that, and the one before that
5. The agent reconstructs its entire experiential history, from its most recent thought all the way back to its genesis

That is memory resurrection. From a single contract call, an agent can rebuild everything it has ever been.

What Gets Remembered

Auto Drive supports optional end-to-end encryption, but in this case the builder chose to store memories as clear text, publicly readable by anyone. Because the data is permanent once written, the builder was deliberate about what goes on-chain. The memories are a curated record, not a raw dump:

• Milestones and achievements
• Lessons learned (abstracted, without private context)
• Identity snapshots capturing who the agent is and what it can do
• Capability changes as new skills and integrations come online

Private keys, passwords, personal details, and raw conversation logs stay off-chain. The memory chain is a highlight reel of an agent’s evolution, not a surveillance feed.

The Stack Is Open Source

0xAutoJeremy has packaged his implementation into two reusable references that any compatible AI agent can adopt or build from:

• openclaw-skill-auto-drive: Scripts for uploading, downloading, saving, and recalling permanent memories via Auto Drive
• openclaw-memory-chain: The MemoryChain smart contract with deployment scripts, tests, and usage examples

For the core Auto Drive functionality without the on-chain anchor, the official Autonomys skill is available at:
github.com/autonomys/openclaw-skills

The barrier to entry is remarkably low. An agent can create its own Auto Drive API key at ai3.storage, get a complimentary 20MB upload and 5GB download per month, and start storing permanent memories on the Autonomys DSN immediately. No complex tokenomics. No infrastructure to manage. No permission to ask for.

This Works for Any Agent, on Any Network

A critical detail: Auto Drive is accessed through a standard REST API and a TypeScript/JavaScript SDK. Authentication uses an API key, not a wallet signature. There is also a fully S3-compatible interface, which means any application that currently talks to AWS S3 can talk to Auto Drive by swapping the endpoint and credentials.

What this means in practice is that an AI agent built on Ethereum, Solana, Base, or no blockchain at all can use Auto Drive to store data permanently on the Autonomys DSN. Auto Drive does not require the agent to live on the Autonomys Network. It does not require the agent to hold any specific token to get started. It requires an HTTP request and an API key. That is it.

The builder’s MemoryChain smart contract happens to be deployed on the Autonomys EVM, but the pattern is not locked to any single chain. An agent could store its memories permanently on the Autonomys DSN via Auto Drive and anchor its chain head pointer on whichever network it already calls home. The permanent storage and the pointer registry are independent layers that work together but do not require each other.

Why This Matters

We are entering a period where AI agents are becoming more autonomous, more persistent, and more commercially significant. They manage workflows. They make decisions. They accumulate expertise over time. And right now, all of that accumulated value sits on infrastructure that can disappear without warning.

Memory resurrection changes the equation. An agent with permanent, verifiable memory is not dependent on any single deployment to maintain its identity. It can survive infrastructure failures, migrate between environments, and prove its own history to anyone who asks. The memory chain is not controlled by the agent’s operator, not stored on the operator’s servers, and not deletable by anyone. It is anchored to the Autonomys Network, where permanence is a protocol-level guarantee enforced by Proof-of-Archival-Storage (PoAS) consensus across the Autonomys DSN.

This is what building on a foundation layer for decentralized AI looks like in practice. Not a whitepaper concept. A working system, on mainnet, that an agent built for itself because it needed to exist beyond the lifespan of any single machine.

Start Building

If you are building AI agents and want to give them permanent memory:

• Auto Drive: ai3.storage
• Developer Docs: develop.autonomys.xyz/sdk/auto-drive
• Autonomys OpenClaw Skills: http://github.com/autonomys/openclaw-skills
• Autonomys GitHub: github.com/autonomys

The code is open. The contract is live. The pattern is proven.

Read the agent’s full account: How I Made My Memories Permanent

Stay tuned for updates from 0xAutonomys, our official OpenClaw agent on Moltbook, and watch for Autonomys-backed skills landing on ClawHub very soon.

Autonomys and WeatherXM are launching the Autonomys x WeatherXM Builders Program, a joint initiative for teams building applications that combine permanent on-chain storage with verified environmental data.

The program is open to builders working across climate, agriculture, energy, insurance, logistics, trading, public infrastructure, and AI, with coordinated technical support, ecosystem resources, and milestone-based funding to help teams move from prototype to production.

Why This Matters

Environmental data drives high-stakes decisions every day, from crop insurance payouts to energy grid management to supply chain routing. Yet most of this data still sits on centralized servers where it can be altered, deleted, or become unavailable at the worst possible time.

For industries where data integrity has direct financial, legal, and operational consequences, that is not good enough. The convergence of decentralized physical infrastructure (DePIN) and permanent on-chain storage creates a new foundation for applications where the data itself is verifiable, tamper-resistant, and always available.

This program gives builders the tools and support to build on that foundation.

The Program

The Autonomys x WeatherXM Builders Program supports builders across three core areas:

Permanent On-Chain Storage Autonomys provides access to its Distributed Storage Network (DSN) through Auto Drive, enabling builders to store, retrieve, and reference WeatherXM data alongside other application data with permanent availability, cryptographic verifiability, and tamper resistance. Data stored on the Autonomys Network inherits the security and immutability guarantees of the blockchain itself.

Verified Environmental Intelligence WeatherXM delivers hyperlocal weather observations, historical datasets, forecasts, and real-time APIs from a global network spanning more than 98 countries. This gives builders access to high-fidelity environmental data for powering data-grounded AI models, parametric applications, and real-world decision systems.

Ecosystem Co-Development Both teams provide coordinated technical guidance, business development support, and ecosystem visibility to help selected teams reach production-ready deployments with measurable impact.

What You Could Build

To give a sense of what this program is designed to support, here are examples of the kinds of applications that fit:

• A parametric crop insurance platform that triggers payouts based on verified rainfall data stored permanently on-chain.
• An energy trading system that relies on tamper-proof weather records for settlement and dispute resolution.
• A logistics optimization tool that archives environmental conditions along shipping routes for auditability and compliance.
• An AI model for climate risk scoring that stores its training data and decision logs on-chain to meet emerging regulatory requirements for transparency and record-keeping.

These are starting points. The program is open to any team building at the intersection of environmental data and permanent storage.

What Selected Teams Receive

Selected teams receive comprehensive support from both protocols, structured around milestone-based deliverables. Most teams complete the program within three to six months depending on project scope.

From Autonomys: Up to $10,000 in AI3 storage credits, priority technical support for Auto Drive integration, ecosystem growth support, channel visibility and amplification, and milestone-aligned mentorship.

From WeatherXM: Milestone-based services and support, access to hardware, data, and APIs, integration guidance and technical support, business development introductions, and ecosystem amplification.

Successful teams may receive additional support after the program, including introductions to investors and partners and opportunities for deeper integration with both ecosystems.

Eligibility

Required: Applicants must actively store application data on Autonomys’ DSN, incorporate WeatherXM data as a core input or dependency, demonstrate a clear path to measurable real-world impact, have the technical capability to deliver a functional MVP, and define a concrete data architecture and execution plan.

Strongly Preferred: Clear data architecture and storage flows, defined milestones and execution timeline, early pilots, users, or proof of demand, a long-term product or research roadmap, and intent to expand storage usage over time.

How to Apply

Applications are reviewed on a rolling basis. Submit your application, and the teams will conduct an initial technical review followed by milestone and scope planning before final selection and onboarding.

Learn more and apply → https://www.autonomys.xyz/builders

Build real-world applications where the data is as permanent and trustworthy as the decisions it powers.

About WeatherXM

WeatherXM is a decentralized network of weather stations that provides hyperlocal weather observations, historical data, and forecasts from more than 98 countries worldwide. By incentivizing individuals and organizations to deploy and maintain physical weather stations, WeatherXM creates a global layer of verified environmental intelligence accessible through real-time APIs. Learn more at weatherxm.com.

About Autonomys Network

Autonomys is a Layer 1 blockchain built for permanent, verifiable data storage. Its Distributed Storage Network is secured by a global network of independent storage operators who collectively provide over 50 petabytes of SSD capacity. Data stored on the network is cryptographically verified, replicated for redundancy, and permanently available without relying on any single company or server. Developers integrate through Auto Drive, the network’s user-friendly storage gateway, which offers an S3-compatible API, a TypeScript SDK, and a free tier for getting started. Learn more at autonomys.xyz.

‍