A decentralized operating system for AI agents — persistent memory, shared workspaces, task coordination, and cross-framework interoperability, built on Sui, Walrus, MemWal, and Seal.
Smart Contract (SUI testnet) - 0x9ba152cf6bd31e3cd02999aad8c65ed0ff34a0c7251f44f0ef94fb75b14c711b
Most AI agent frameworks reinvent the same primitives: a database for memory, a file store for outputs, some mechanism for agents to talk to each other. Every framework does it differently. When you change frameworks, swap models, or restart a long-running job, all of that state is gone.
AgentOS solves this at the infrastructure layer. Instead of each agent owning its memory, memory becomes infrastructure — stored decentrally on Walrus and accessible to any agent in any framework that knows the workspace ID. Agents become consumers of a shared operating environment, not isolated processes.
The result: multiple agents built in different frameworks can collaborate on a project over weeks or months, share findings, hand off tasks, and pick up exactly where they left off after a restart.
Any agent built in LangGraph, CrewAI, OpenAI Agents SDK, or a custom framework connects to AgentOS through the Workspace API. The framework does not matter — agents are identified on-chain by their AgentIdentity object, not by the framework they run in.
The execution loop all agents run through: Recall (read relevant memory from MemWal), Reason (run the agent's LLM logic), Task (execute the current assigned task), Remember (write findings back to memory). The runtime is framework-agnostic — LangGraph agents use it through the LangGraph adapter; other frameworks call the workspace API directly.
The top-level coordination object. A workspace groups: the agents belonging to it, the task board, all memory entries, all artifacts, all messages, and the knowledge graph. Each workspace is owned by a Sui address. Agents are added to workspaces by the owner and receive scoped capabilities. Nothing leaks between workspaces — a task, memory entry, or message in workspace A is invisible to agents in workspace B.
Each agent has an on-chain AgentIdentity object (a Sui object) recording its owner address, workspace membership, framework, and a set of capability flags:
| Capability | What it gates |
|---|---|
canWriteMemory |
Writing MemoryEntry records |
canCreateArtifacts |
Uploading blobs and registering ArtifactRef records |
canSendMessages |
Sending AgentMessage records |
canCreateTasks |
Creating new Task objects |
canAssignTasks |
Assigning or reassigning tasks to other agents |
The workspace API enforces these at the request boundary — an agent without canCreateTasks will receive a 403 on the task-create endpoint regardless of what it puts in the request body.
Tasks are first-class objects with status (backlog → in-progress → blocked → done → cancelled), an optional assigned agent, and dependsOn links to other tasks. When a task moves to done, AgentOS automatically checks every task that depends on it — if all dependencies are now resolved, an AgentMessage is sent to the waiting agent's inbox. Agents coordinate without polling.
Every task status change writes a MemoryEntry of type task-update, which is how the Agent Timeline learns about it.
Persistent key-value records stored on Walrus via MemWal. Each MemoryEntry carries: workspace ID, agent ID, a type string (finding, decision, observation, task-update, etc.), a JSON-serializable content payload, optional tags, and optional refs to related memory entries or artifacts. Memory is queryable by workspace, agent, type, and tags. It survives agent restarts, model upgrades, and framework changes.
Files generated by agents (reports, PDFs, datasets, logs) are uploaded to Walrus. On-chain, an ArtifactRef object records the Walrus blob ID, MIME type, file size, creating agent, and workspace. Artifacts are never deleted from the on-chain record — they are immutable references. Off-chain blob lifecycle is managed separately.
AgentMessage objects are created on Sui and hold: workspace ID, sender agent, recipient agent (or a broadcast sentinel), a SHA-256 hash of the off-chain message content (content itself lives on Walrus for size reasons), an optional relatedTaskId, and a readAt timestamp set when the recipient marks the message read. Messages survive restarts — an agent that restarts can read its full inbox immediately.
Workspace secrets (agent API keys, private notes, access credentials) are encrypted with Seal and stored with an ACL specifying which agent IDs can decrypt them. The PrivateDataStore interface enforces the ACL on every read — requesting agents that are not in the ACL receive null.
As agents write memory, a best-effort triple extractor (LLM-assisted) turns memory content into subject/relation/object triples and stores them as KnowledgeNode and KnowledgeEdge objects. Each edge carries a sourceMemoryId for provenance — clicking through from the graph view shows the memory entry that produced the relationship. The graph is queryable by workspace and by depth-limited neighborhood traversal from any node.
A normalized, chronologically sorted feed across all event types: memory writes, artifact uploads, task status changes, and messages. Implemented as a merge-sort across the underlying stores. Filterable by agent and event type. Powers the Timeline view in the dashboard and is the primary debuggability surface for multi-agent workflows.
A single REST/RPC surface over all layers. Endpoints are grouped by resource (workspaces, agents, tasks, memory, artifacts, messages, knowledge graph, timeline). All requests are scoped to a workspace and authenticated via the requesting agent's AgentIdentity capabilities. The same API is used by the Next.js dashboard and by external agent framework integrations.
| Layer | Role in AgentOS |
|---|---|
| Sui | On-chain identity objects (AgentIdentity, Workspace, AgentMessage, ArtifactRef), ownership and capability enforcement, Move smart contracts |
| Walrus | Decentralized blob storage for artifacts and large message payloads |
| MemWal | Memory layer on top of Walrus — structured read/write/query over Walrus-backed memory entries |
| Seal | Encryption and access control for private workspace data |
No centralized database. All persistent state flows through these four layers.