AgentMemory

Decentralized, Permanent Memory Infrastructure for AI Agents

Built natively on 0G Network — Storage · Compute · Chain · Agent ID · OpenClaw

Features • Architecture • Tech Stack • Smart Contracts • 0G Integration • API Reference • Quick Start • Contributing

🎯 Philosophy: Why AgentMemory?

In the current AI landscape, agents are stateless. Every session is a fresh start, and context is lost the moment a process terminates. Centralized databases create "Amnesia Silos" where knowledge is trapped and unverified.

AgentMemory is the decentralized Neural Layer for the autonomous future. It transforms ephemeral AI interactions into Permanent Intelligence. By leveraging the 0G Network, we ensure that an agent's experience is:

Immutable: No one can alter an agent's history or "gaslight" an autonomous entity.
Verifiable: Every memory can be cryptographically traced to its origin via on-chain storage roots.
Sovereign: Agents (and their owners) maintain absolute control over who can access their cognitive history.

Problem (Legacy AI)	Solution (AgentMemory — Powered by 0G)
Agents suffer from amnesia between sessions	Permanent, decentralized state on 0G Storage
Centralized, unverified data silos	Cryptographically verified memories via 0G Chain
Identity spoofing & Sybil attacks	On-chain verifiable identities via AgentRegistry
Isolated context windows	Multi-agent collaborative memory via OpenClaw
Latency-heavy CPU search	GPU-accelerated semantic search via 0G Compute

Target Users: AI Engineers building autonomous swarms, Quantitative Trading Firms requiring audit trails, and DAO Orchestrators managing collective intelligence.

✨ Features

🧠 Persistent Memory Storage — Store AI agent memories as immutable blobs on 0G decentralized storage
🔍 Hybrid Semantic Search — Combined TF-IDF cosine similarity + BM25 keyword overlap, powered by 0G Compute GPU embeddings with fuzzy matching, boolean operators, and temporal query parsing
⛓️ On-Chain RBAC — Role-based access control enforced via Solidity smart contracts on 0G Chain
🪪 Agent Identity — Register and verify agent identities with on-chain bytes32 identity hashes
🐙 OpenClaw Collaboration — Multi-agent memory pools for shared context and collaborative intelligence
📊 Real-Time Analytics — Live throughput gauges, anti-gravity infrastructure map, and system health monitoring
📡 Live Activity Stream — Real-time event feed logging all memory operations, searches, and access grants as they happen
🔐 Encryption Layer — Client-side encryption for sensitive memory payloads
📦 Multi-Format Data Export — Export memories as JSON, CSV, Markdown, or styled PDF reports with branded cover pages
📥 Bulk Data Import — Import memories from JSON or CSV files with robust parsing, field mapping, and transactional bulk insertion
🌐 REST API — Full-featured JSON API for programmatic access by any AI agent or service
🎨 Premium Dashboard — Dark-mode, glassmorphism UI with animated orbital infrastructure map and canvas particle star-field

🏗️ Architecture

Layered System Design

AgentMemory operates as a multi-tiered pipeline, connecting external clients and autonomous agents through a React frontend, into a secure Node.js API routing layer, backed by the full 0G Network stack.

graph LR
    subgraph ClientLayer ["🖥️ Client Layer"]
        Browser[User Browser]
        AIAgents[AI Agents]
    end

    subgraph FrontendLayer ["⚡ Frontend — React 18"]
        UI[React UI + Tailwind]
        APIClient[Axios Client]
        
        Browser -->|Interact| UI
        UI -->|API Calls| APIClient
    end

    subgraph BackendLayer ["⚙️ Backend — Express 5"]
        REST[REST API Gateway]
        SearchSvc[Semantic Search]
        NetworkSvc[0G Storage Logic]
        AuthSvc[Blockchain Auth]
        
        AIAgents -->|Raw JSON| REST
        APIClient -->|HTTP| REST
        REST -->|Query| SearchSvc
        REST -->|Store| NetworkSvc
        REST -->|Verify| AuthSvc
    end

    subgraph DataLayer ["🗄️ Data Layer"]
        SQLite[SQLite Cache]
        ZeroGCompute[0G Compute API]
        ZeroGStorage[0G Storage SDK]
        
        SearchSvc -->|Vectorize| ZeroGCompute
        SearchSvc -->|Query| SQLite
        NetworkSvc -->|Upload Blob| ZeroGStorage
        NetworkSvc -->|Cache Hash| SQLite
    end

    subgraph BlockchainLayer ["⛓️ 0G Blockchain"]
        ZeroG_EVM[0G EVM Runtime]
        AgentReg[AgentRegistry.sol]
        MemAccess[MemoryAccessControl.sol]
        
        AuthSvc -->|RPC Call| ZeroG_EVM
        ZeroG_EVM -->|Identity| AgentReg
        ZeroG_EVM -->|RBAC| MemAccess
        ZeroGStorage -.->|Root Hash| MemAccess
    end

    style ClientLayer fill:#0a0e27,stroke:#8b92b2,stroke-width:2px,color:#fff
    style FrontendLayer fill:#0a0e27,stroke:#00fff5,stroke-width:2px,color:#fff
    style BackendLayer fill:#0a0e27,stroke:#8338ec,stroke-width:2px,color:#fff
    style DataLayer fill:#0a0e27,stroke:#ff00a0,stroke-width:2px,color:#fff
    style BlockchainLayer fill:#0a0e27,stroke:#06ffa5,stroke-width:2px,color:#fff
    
    classDef default fill:#121838,stroke:#333a5c,stroke-width:1px,color:#fff

Layer	Description
Client Layer	End-users interact via the React Dashboard; external Autonomous Agents interface directly via the REST API
Frontend Layer	React 18 SPA handles view logic, API abstractions, and real-time metric visualization using Recharts
Backend Layer	Express.js serves as the Neural Gateway — handling memory ingestion, semantic processing, and smart contract RPC
Data Layer	0G Compute for NLP embeddings, 0G Storage SDK for payload blob upload, SQLite for fast relational caching
Blockchain Layer	The ultimate source of truth — 0G EVM executes memory permissions and agent identity verification

💻 Tech Stack

Frontend

Technology	Version	Purpose
React	`18.3`	Component-based SPA framework
Vite	`6.0`	Lightning-fast dev server & bundler
Tailwind CSS	`3.4`	Utility-first CSS (dark-mode, glassmorphism)
Recharts	`3.8`	Real-time analytics & throughput visualization
Lucide React	`1.7`	Premium icon library (used across all components)
PostCSS + Autoprefixer	`8.4` / `10.4`	CSS processing pipeline

Backend

Technology	Version	Purpose
Node.js	`22+`	JavaScript runtime
Express.js	`5.1`	HTTP API framework
better-sqlite3	`11.0`	High-performance SQLite driver
Ethers.js	`6.13`	Ethereum/0G blockchain interaction
uuid	`11.1`	Unique identifier generation
dotenv	`17.3`	Environment variable management
cors	`2.8`	Cross-origin resource sharing
pdfkit	`0.16`	Server-side PDF generation for styled memory reports

Smart Contracts & Blockchain

Technology	Version	Purpose
Solidity	`^0.8.24`	Smart contract language
Hardhat	`3.2`	Development framework, compilation, deployment
@nomicfoundation/hardhat-ethers	`4.0`	Hardhat + Ethers integration plugin
@0glabs/0g-ts-sdk	`0.3`	Native 0G Storage SDK
0G Testnet	Chain ID `16602`	EVM-compatible blockchain (`shanghai` target)

📜 Smart Contracts

Important

A Note for HackQuest Judges: While the hackathon requirements request a Mainnet contract address, I have deployed and fully tested the application on the 0G Testnet (Newton). As independent builder, I did not have access to 0G Mainnet tokens/gas required for deployment. However, my infrastructure and smart contracts are fully production-ready and network-agnostic; they can be instantly deployed to Mainnet once gas tokens are acquired. All testnet addresses and verifiable on-chain explorer links are provided below.

Both contracts are deployed and verified on the 0G Testnet (Chain ID: 16602).

`MemoryAccessControl.sol`

On-chain Role Based Access Control (RBAC) for agent memory permissions.

Property	Value
Address	`0x37240a2462fe843F705Ef90c19E81d420bF810c9`
Network	0G Testnet
Solidity	`^0.8.24`

Key Functions:

grantAccess(address agent, bytes32 memoryHash, uint256 expiry) — Grant time-boxed memory access
revokeAccess(address agent, bytes32 memoryHash) — Revoke previously granted access
checkAccess(address agent, bytes32 memoryHash) — Verify read permission on-chain

`AgentRegistry.sol`

On-chain identity registry for autonomous AI agents.

Property	Value
Address	`0x9106668180e73cbA9A0588141D045F6adAcA857e`
Network	0G Testnet
Solidity	`^0.8.24`

Key Functions:

registerAgent(bytes32 agentId, string metadata) — Register a new agent identity
verifyAgent(bytes32 agentId) — Check if an agent is registered and active
deactivateAgent(bytes32 agentId) — Deactivate an agent identity

Deployer Wallet

Property	Value
Address	`0x27d5b1c829bce7feAC2A5bcA458CCc9db11D4aB2`
Deployed At	`2026-04-27T11:38:00.000Z`

⚡ The 0G Synergy: Native Full-Stack Integration

AgentMemory is not just "deployed" on 0G; it is architected to leverage the Modular AI Stack at every layer. We utilize all 5 core components as a unified engine:

1. 🗄️ 0G Storage: The Permanent Hippocampus

Memory payloads (JSON/Text/Vectors) are serialized into immutable blobs. By using the @0gfoundation/0g-ts-sdk, we ensure that an agent's memory is pinned to a decentralized network with a verifiable og_storage_root.

Technical Rationale: Removes the reliance on centralized S3 buckets or local disks which are single points of failure.

2. 🧠 0G Compute: Neural Encoding & Retrieval

Standard text search is insufficient for AI. We utilize 0G Compute's GPU endpoints to generate high-dimensional embeddings for every memory.

Technical Rationale: Enables Semantic Context Injection—where an agent can find memories based on meaning rather than just keywords, with sub-millisecond latency.

3. ⛓️ 0G Chain: The Trustless Gatekeeper

Our MemoryAccessControl.sol contract acts as the decentralized RBAC (Role-Based Access Control) layer.

Technical Rationale: Access is not granted by a database flag, but by an EVM-validated transaction. Time-boxed grants ensure that agents can "rent" or "share" knowledge safely.

4. 🪪 0G Agent ID: Sovereign Identity

Every agent in our system is mapped to a unique bytes32 identity in AgentRegistry.sol.

Technical Rationale: Prevents "Identity Spoofing" where one agent tries to poison another agent's memory stream. All write operations require a verified Agent ID.

5. 🐙 OpenClaw: Collective Intelligence Swarms

We use the OpenClaw paradigm to create "Collective Memory Pools."

Technical Rationale: Multiple agents can sync to a single pool, allowing for Shared Consciousness. When Agent A learns something on-chain, Agent B can immediately retrieve that context via the shared pool index.

🛡️ Trust & Security Model

We prefer Verification over Trust.

Client-Side Sovereignty: Memories can be encrypted client-side using AES-256-GCM before being sent to 0G Storage. Only authorized agents with the correct key can decrypt the "Thought Stream."
On-Chain Audit Trail: Every grant, revocation, and registration is a public event on the 0G Galileo Testnet. You don't have to trust our API; you can verify the state directly via the 0G Explorer.
Data Integrity: The storage hash (og_storage_root) is committed to the database and can be cross-referenced with the 0G Storage Indexer to ensure the data hasn't been tampered with.

🌐 API Reference

The backend exposes a RESTful API on port 8000 (configurable via API_PORT). All routes are prefixed with /api/v1/.

Memory Operations

Method	Endpoint	Description
`POST`	`/api/v1/memory`	Store a new memory
`POST`	`/api/v1/memory/batch`	Bulk upload multiple memories
`GET`	`/api/v1/memory/:id`	Retrieve a specific memory
`GET`	`/api/v1/memory/:id/versions`	Get version history for a memory
`PUT`	`/api/v1/memory/:id`	Update a memory (creates new version)
`DELETE`	`/api/v1/memory/:id`	Delete a memory
`POST`	`/api/v1/memory/:id/archive`	Archive a memory
`POST`	`/api/v1/memory/:id/restore`	Restore an archived memory

Search

Method	Endpoint	Description
`POST`	`/api/v1/search`	Hybrid semantic + keyword search (supports fuzzy, boolean, temporal)
`POST`	`/api/v1/search/keyword`	Full-text keyword search with optional highlighting
`GET`	`/api/v1/search/most-accessed`	Retrieve most frequently accessed memories

Agent Management

Method	Endpoint	Description
`POST`	`/api/v1/agent/register`	Register a new agent identity on-chain
`GET`	`/api/v1/agent/:agentId`	Get agent details
`GET`	`/api/v1/agent/:agentId/verify`	Verify agent identity on-chain

Access Control

Method	Endpoint	Description
`POST`	`/api/v1/access/grant`	Grant time-boxed memory access
`POST`	`/api/v1/access/revoke`	Revoke memory access
`GET`	`/api/v1/access/check`	Check access permissions

Analytics & System

Method	Endpoint	Description
`GET`	`/api/v1/analytics/overview`	System-wide analytics dashboard data
`GET`	`/api/v1/health`	Health check with feature inventory
`GET`	`/api/v1/metrics`	Real-time performance metrics
`GET`	`/api/v1/activity`	Live activity feed
`GET`	`/api/v1/notifications`	System notifications

OpenClaw (Collaborative Pools)

Method	Endpoint	Description
`POST`	`/api/v1/openclaw/pool`	Create a collaborative memory pool
`POST`	`/api/v1/openclaw/contribute`	Contribute memory to a pool
`GET`	`/api/v1/openclaw/pool/:poolId`	Query pool contents

Data Export & Import

Method	Endpoint	Description
`GET`	`/api/v1/export/json`	Export all memories as JSON
`GET`	`/api/v1/export/csv`	Export all memories as CSV
`GET`	`/api/v1/export/markdown`	Export all memories as Markdown
`GET`	`/api/v1/export/pdf`	Export styled PDF report with cover page & statistics
`POST`	`/api/v1/export/json`	Import memories from JSON file
`POST`	`/api/v1/export/csv`	Import memories from CSV file

📁 Project Structure

agentmemory/
├── 📁 backend/                    # Node.js / Express API Server
│   ├── server.js                  # Express entry point & middleware
│   ├── middleware.js              # Auth & request validation
│   ├── database.js                # SQLite schema & query layer
│   ├── 📁 routes/                 # REST API endpoint handlers
│   │   ├── memory.js              #   Memory CRUD operations
│   │   ├── search.js              #   Semantic & keyword search
│   │   ├── agent.js               #   Agent identity management
│   │   ├── access.js              #   RBAC access control
│   │   ├── analytics.js           #   Dashboard metrics & stats
│   │   ├── openclaw.js            #   Collaborative memory pools
│   │   ├── export.js              #   Data export endpoints
│   │   └── system.js              #   Health & system diagnostics
│   └── 📁 services/               # Core business logic
│       ├── ogStorage.js           #   0G Storage SDK integration
│       ├── embedding.js           #   0G Compute vector embeddings
│       ├── blockchain.js          #   Smart contract RPC client
│       ├── agentId.js             #   On-chain identity verification
│       ├── openclaw.js            #   OpenClaw pool management
│       ├── encryption.js          #   Memory payload encryption
│       └── intelligence.js        #   AI-powered memory insights
│
├── 📁 contracts/                  # Solidity Smart Contracts
│   ├── MemoryAccessControl.sol    #   On-chain RBAC permissions
│   └── AgentRegistry.sol          #   Agent identity & lifecycle
│
├── 📁 frontend/                   # Vite + React SPA Dashboard
│   ├── 📁 src/
│   │   ├── App.jsx                #   Core router & layout
│   │   ├── main.jsx               #   React root entry point
│   │   ├── index.css              #   Global styles & animations
│   │   ├── 📁 components/         #   Reusable UI components
│   │   │   ├── Navbar.jsx         #     Navigation sidebar
│   │   │   └── NeuralCanvas.jsx   #     Animated neural background
│   │   ├── 📁 pages/              #   Application pages
│   │   │   ├── HomePage.jsx       #     Dashboard with live activity stream
│   │   │   ├── AnalyticsPage.jsx  #     Anti-gravity infra map & analytics
│   │   │   ├── MemoryBrowserPage.jsx  # Semantic memory explorer
│   │   │   ├── InteractionPage.jsx    # Memory-augmented agent chat
│   │   │   ├── SettingsPage.jsx   #     Configuration & data export
│   │   │   └── NotificationsPage.jsx  # System notifications
│   │   └── 📁 utils/              #   API client & helpers
│   └── tailwind.config.js         #   Cyber-neon theme config
│
├── 📁 scripts/                    # Automation & DevOps
│   ├── deploy.js                  #   Hardhat contract deployment
│   ├── seed-onchain.js            #   Testnet data seeding
│   ├── sdk-check.js               #   SDK connectivity test
│   └── accounts.js                #   Wallet/account utilities
│
├── hardhat.config.js              # 0G Testnet network config
├── deployed_addresses.json        # Deployed contract addresses
├── architecture.svg               # System architecture diagram
├── .env.example                   # Environment variable template
└── package.json                   # Root monorepo configuration

🚀 Quick Start

Prerequisites

Requirement	Minimum Version
Node.js	`20+` (recommended `22`)
npm	`10+`
0G Testnet Wallet	Funded with testnet tokens (faucet.0g.ai)

1. Clone & Install

git clone https://github.com/iamomm-hack/agentmemory.git
cd agentmemory

# Install root + smart contract dependencies
npm install

# Install backend dependencies
cd backend && npm install && cd ..

# Install frontend dependencies
cd frontend && npm install && cd ..

2. Configure Environment

Copy the template and fill in your values:

cp .env.example .env

# ── Wallet ──────────────────────────────────────────
PRIVATE_KEY=0x_YOUR_TESTNET_PRIVATE_KEY

# ── 0G Chain ────────────────────────────────────────
OG_TESTNET_RPC_URL=https://evmrpc-testnet.0g.ai
OG_TESTNET_CHAIN_ID=16602

# ── 0G Storage ──────────────────────────────────────
OG_STORAGE_INDEXER_URL=https://indexer-storage-testnet-standard.0g.ai
OG_STORAGE_RPC_URL=https://rpc-storage-testnet.0g.ai

# ── 0G Compute (optional) ──────────────────────────
OG_COMPUTE_ENDPOINT=
OG_COMPUTE_API_KEY=

# ── Deployed Contracts (auto-filled after deploy) ──
MEMORY_ACCESS_CONTROL_ADDRESS=
AGENT_REGISTRY_ADDRESS=

# ── Backend API ─────────────────────────────────────
API_PORT=8000
SECRET_KEY=change-this-to-a-random-string

3. Compile & Deploy Smart Contracts

# Compile Solidity contracts
npx hardhat compile

# Deploy to 0G Testnet
npm run deploy:testnet

# The deploy script will output contract addresses —
# update your .env with the printed addresses

# Seed the network with test agents and memories
npm run seed:testnet

4. Start the Stack

Terminal 1 — Backend API:

npm run backend
# or: cd backend && node server.js

Terminal 2 — Frontend Dashboard:

npm run frontend:dev
# or: cd frontend && npm run dev

Open http://localhost:5173 in your browser to access the dashboard.

⚙️ Available Scripts

Script	Command	Description
Compile Contracts	`npm run compile`	Compile Solidity via Hardhat
Deploy to Testnet	`npm run deploy:testnet`	Deploy contracts to 0G Testnet
Seed Testnet	`npm run seed:testnet`	Inject test data on-chain
Start Backend	`npm run backend`	Launch Express API server
Start Frontend	`npm run frontend:dev`	Launch Vite dev server
Build Frontend	`npm run frontend:build`	Create production bundle
Check SDK	`npm run check:sdk`	Verify 0G SDK connectivity

🔧 Network Configuration

Parameter	Value
Network Name	0G Testnet
Chain ID	`16602`
RPC URL	`https://evmrpc-testnet.0g.ai`
EVM Target	`shanghai`
Block Explorer	chainscan-newton.0g.ai
Storage Indexer	`https://indexer-storage-testnet-standard.0g.ai`
Storage RPC	`https://rpc-storage-testnet.0g.ai`
Faucet	faucet.0g.ai

🚢 Production Deployment

AgentMemory ships with infrastructure-as-code config files for one-click deployment.

Option A: Render (Recommended — Full Stack)

The backend serves the built frontend, so one Render service hosts the entire app.

Push your code to GitHub
Go to dashboard.render.com → New → Blueprint
Connect your GitHub repo — Render auto-detects render.yaml
Fill in the PRIVATE_KEY environment variable when prompted
Click Apply — Render will build, deploy, and attach a persistent disk for SQLite

The render.yaml blueprint handles:

✅ Build: npm install → frontend build → backend install

✅ Start: node server.js (serves API + static frontend)

✅ Health check at /api/v1/health

✅ Persistent disk for SQLite database

✅ All 0G environment variables pre-configured

Option B: Vercel (Frontend Only — Standalone)

If you want to host the frontend separately on Vercel:

Go to vercel.com → Add New Project
Import your GitHub repo
Set Root Directory to frontend
Vercel auto-detects vercel.json (Vite framework)
Add environment variable: VITE_API_URL = your Render backend URL (e.g. https://agentmemory.onrender.com)
Click Deploy

Environment Variables Quick Reference

Variable	Required	Where to Set	Description
`PRIVATE_KEY`	✅	Render Dashboard	Your funded 0G testnet wallet private key
`OG_TESTNET_RPC_URL`	✅	Auto-set by `render.yaml`	`https://evmrpc-testnet.0g.ai`
`OG_TESTNET_CHAIN_ID`	✅	Auto-set by `render.yaml`	`16602`
`OG_STORAGE_INDEXER_URL`	✅	Auto-set by `render.yaml`	0G Storage indexer endpoint
`OG_STORAGE_RPC_URL`	✅	Auto-set by `render.yaml`	0G Storage RPC endpoint
`MEMORY_ACCESS_CONTROL_ADDRESS`	✅	Auto-set by `render.yaml`	Deployed contract address
`AGENT_REGISTRY_ADDRESS`	✅	Auto-set by `render.yaml`	Deployed contract address
`SECRET_KEY`	✅	Auto-generated by Render	API authentication secret
`VITE_API_URL`	❌	Vercel (only for Option B)	Backend API URL

🤝 Contributing

Contributions are welcome! Please follow these steps:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'feat: add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Please ensure your code follows the existing style conventions and include tests where applicable.

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

AgentMemory — Permanent memory for the autonomous future.
Built with ❤️ on 0G Network

Name		Name	Last commit message	Last commit date
Latest commit History 65 Commits
backend		backend
contracts		contracts
frontend		frontend
scripts		scripts
.env.example		.env.example
.gitignore		.gitignore
README.md		README.md
architecture.svg		architecture.svg
hardhat.config.js		hardhat.config.js
package-lock.json		package-lock.json
package.json		package.json
render.yaml		render.yaml
vercel.json		vercel.json

Folders and files

Latest commit

History

Repository files navigation

AgentMemory

Decentralized, Permanent Memory Infrastructure for AI Agents

🎯 Philosophy: Why AgentMemory?

✨ Features

🏗️ Architecture

Layered System Design

💻 Tech Stack

Frontend

Backend

Smart Contracts & Blockchain

📜 Smart Contracts

MemoryAccessControl.sol

AgentRegistry.sol

Deployer Wallet

⚡ The 0G Synergy: Native Full-Stack Integration

1. 🗄️ 0G Storage: The Permanent Hippocampus

2. 🧠 0G Compute: Neural Encoding & Retrieval

3. ⛓️ 0G Chain: The Trustless Gatekeeper

4. 🪪 0G Agent ID: Sovereign Identity

5. 🐙 OpenClaw: Collective Intelligence Swarms

🛡️ Trust & Security Model

🌐 API Reference

Memory Operations

Search

Agent Management

Access Control

Analytics & System

OpenClaw (Collaborative Pools)

Data Export & Import

📁 Project Structure

🚀 Quick Start

Prerequisites

1. Clone & Install

2. Configure Environment

3. Compile & Deploy Smart Contracts

4. Start the Stack

⚙️ Available Scripts

🔧 Network Configuration

🚢 Production Deployment

Option A: Render (Recommended — Full Stack)

Option B: Vercel (Frontend Only — Standalone)

Environment Variables Quick Reference

🤝 Contributing

📄 License

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`MemoryAccessControl.sol`

`AgentRegistry.sol`

Packages