Give Your AI Agent Decentralized Storage

AI agents are graduating from demos to production. They run autonomously, process data, write files, store memory, and generate outputs. Somewhere behind every useful agent is a storage layer.

Most teams reach for AWS S3 by default. But if you're building on Bittensor, or if you care about censorship-resistant, vendor-independent infrastructure, there's a better option: Hippius.

The storage problem for AI agents

Without persistent state, an agent is just a stateless function.

Modern AI agents need to store intermediate reasoning and scratchpad state for working memory. They accumulate long-term knowledge in the form of vector embeddings, retrieved documents, and processed datasets. They produce outputs like generated files or reports. They also write logs and traces for debugging and auditing, along with checkpoints so long-running tasks can resume after interruption.

The standard answer is S3. It's simple, well-supported by every SDK, and battle-tested. The problem is that it's centralized, subject to account suspension, and you're trusting Amazon with your agent's brain.

What is llms.txt?

llms.txt is an emerging standard for making APIs and documentation directly consumable by LLMs and AI agents. Similar to robots.txt for web crawlers, llms.txt provides a machine-readable index of your documentation, structured so that AI agents can understand and use your API without human assistance.

Hippius has a complete llms.txt at docs.hippius.com/llms.txt.

This means any AI agent (Claude, GPT-4, Gemini, or a custom LLM) can read Hippius documentation natively, understand the S3 API surface, and start using it without any fine-tuning or custom tooling.

# What an agent sees at docs.hippius.com/llms.txt

Endpoint: https://s3.hippius.com
Region: decentralized
Signature: AWS Signature V4

Common Operations (AWS CLI):
  aws s3 mb s3://my-bucket --endpoint-url https://s3.hippius.com
  aws s3 cp file.txt s3://my-bucket/ --endpoint-url https://s3.hippius.com
  ...

An agent that can read this can use Hippius immediately. No wrapper libraries. No custom integrations. Just S3.

Hippius + AI agents: practical examples

LangChain document store

LangChain has native S3 support. Point it at Hippius:

from langchain_community.document_loaders import S3FileLoader
import boto3
from botocore.config import Config

# Configure S3 client pointing at Hippius
s3_client = boto3.client(
    "s3",
    endpoint_url="https://s3.hippius.com",
    aws_access_key_id="hip_your_key",
    aws_secret_access_key="your_secret",
    region_name="decentralized",
    config=Config(signature_version="s3v4", s3={"addressing_style": "path"}),
)

# Load documents from decentralized storage
loader = S3FileLoader(
    bucket="my-agent-knowledge-base",
    key="documents/context.pdf",
    boto3_client=s3_client,
)
docs = loader.load()

Your agent's knowledge base, stored on a decentralized network of 459+ independent nodes.

Claude tool use: agent with persistent memory

Give Claude a tool to read and write files on Hippius:

import anthropic
import boto3
from botocore.config import Config
import json

s3 = boto3.client(
    "s3",
    endpoint_url="https://s3.hippius.com",
    aws_access_key_id="hip_your_key",
    aws_secret_access_key="your_secret",
    region_name="decentralized",
    config=Config(signature_version="s3v4", s3={"addressing_style": "path"}),
)

tools = [
    {
        "name": "save_to_storage",
        "description": "Save a file to decentralized storage. Use this to persist data, outputs, or memory.",
        "input_schema": {
            "type": "object",
            "properties": {
                "filename": {"type": "string", "description": "Path/filename to save"},
                "content": {"type": "string", "description": "Content to save"},
            },
            "required": ["filename", "content"],
        },
    },
    {
        "name": "read_from_storage",
        "description": "Read a file from decentralized storage.",
        "input_schema": {
            "type": "object",
            "properties": {
                "filename": {"type": "string", "description": "Path/filename to read"},
            },
            "required": ["filename"],
        },
    },
]

def handle_tool_call(tool_name, tool_input):
    if tool_name == "save_to_storage":
        s3.put_object(
            Bucket="agent-memory",
            Key=tool_input["filename"],
            Body=tool_input["content"].encode(),
        )
        return f"Saved to {tool_input['filename']}"
    elif tool_name == "read_from_storage":
        obj = s3.get_object(Bucket="agent-memory", Key=tool_input["filename"])
        return obj["Body"].read().decode()

client = anthropic.Anthropic()

# Agent with decentralized persistent memory
response = client.messages.create(
    model="claude-opus-4-5",
    max_tokens=4096,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": "Research the latest Bittensor subnet launches and save a summary to storage.",
        }
    ],
)

The agent's outputs persist on Hippius, retrievable and verifiable on-chain, without depending on any single cloud provider.

OpenAI Agents SDK: file search over decentralized storage

from openai import OpenAI
import boto3
from botocore.config import Config

# Sync files from Hippius to use with OpenAI file search
s3 = boto3.client(
    "s3",
    endpoint_url="https://s3.hippius.com",
    aws_access_key_id="hip_your_key",
    aws_secret_access_key="your_secret",
    region_name="decentralized",
    config=Config(signature_version="s3v4", s3={"addressing_style": "path"}),
)

# Download context files from Hippius
s3.download_file("knowledge-base", "docs/hippius-overview.pdf", "/tmp/overview.pdf")

client = OpenAI()

# Upload to OpenAI files API for vector search
with open("/tmp/overview.pdf", "rb") as f:
    file = client.files.create(file=f, purpose="assistants")

print(f"File ready for agent search: {file.id}")

n8n: automated agent workflows

In n8n, use the AWS S3 node and swap the endpoint:

Any n8n workflow that reads/writes S3 now reads/writes Hippius. No other changes.

Why decentralized storage matters for agent infrastructure

Your agent's memory and outputs are stored on an open network, so there's no vendor lock-in. You can switch providers, self-custody your data, or migrate without asking Amazon for permission.

An agent working on sensitive research, legal documents, or politically contentious content shouldn't have to worry about platform-level account suspension deleting its working memory. Decentralized storage removes that risk.

Hippius is built on Bittensor (Subnet 75), the same network powering the AI agent revolution. You can pay for storage with TAO, and your agent's infrastructure lives in the same incentive-aligned ecosystem it operates in.

Every storage operation is also logged on the Hippius blockchain. An agent's outputs are auditable, provably stored, and timestamp-verified. For compliance-sensitive applications, this is a significant advantage over traditional cloud storage.

Under the hood: how Hippius stores your agent's data

When your agent writes a file to Hippius:

1. The file is split into 30 shards (10 data + 20 parity) using Reed-Solomon erasure coding
2. Shards are distributed across 459+ independent miners using the CRUSH algorithm, with deterministic placement and no DHT lookup
3. To retrieve the file, only any 10 of 30 shards are needed, so the network survives 66% node loss with your data intact
4. The Arion validator continuously monitors shard health and rebuilds missing shards automatically

From your agent's perspective, it's S3. Under the hood, it's infrastructure that IPFS and centralized clouds can't match.

Get started

1. Create an account at console.hippius.com with Google or GitHub OAuth.
2. Get credentials in Console → S3 Storage → Create Master Token.
3. Point your agent at Hippius:
   Copy

   endpoint_url = "https://s3.hippius.com"
   region = "decentralized"
   

4. Read the llms.txt file at docs.hippius.com/llms.txt.

That's it. Any S3-compatible agent framework (LangChain, OpenAI Agents, Claude tool use, n8n, AutoGen) works with Hippius out of the box.

What's next

We're actively building deeper agent integrations: a native LangChain vector store adapter, an MCP (Model Context Protocol) server for Hippius storage, and direct TAO billing for agent-to-agent micropayments.

Follow updates at community.hippius.com and @hippius_subnet.

Have you built an agent that uses Hippius storage? Share it in the community forum. We'd love to feature your work.