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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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 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.
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
Фундаментальный уровень для AI3.0
