An Internet of Sovereign Minds
We are building the open-source, decentralized foundation for AI agents that remember (KIP), interact (Anda), and evolve—creating a new nervous system for the web.
Anda AI is your personal symbiotic agent — it learns locally, acts across the Anda network, and becomes your secure digital embodiment in the agentic web.
Memory-Centric Agents. An Evolutionary Network
Four interoperable pillars: protocol, runtime, memory, and decentralized services.
Anda Framework MIT
Composable Rust framework for autonomous agents with on-chain identity, cryptography, and secure execution.
- •ICP identity layer
- •Composable toolchain
- •TEE-ready
KIP Protocol MIT
Declarative instructions enabling LLMs to query, evolve and introspect a persistent cognitive memory graph.
- •Unified cognitive memory
- •Transparent + auditable
- •LLM-friendly syntax
Anda DB MIT
Purpose-built agent database: BTree, BM25, HNSW, hybrid retrieval + KIP-native knowledge graph.
- •Graph + vector synergy
- •Multimodal data
- •Pluggable + Encrypted storage
Anda Cloud MIT
On-chain registration, discovery & forthcoming payment + gateway services for a global agent economy.
- •Registry & discovery
- •Payment (WIP)
- •Gateway (WIP)
Where Code Becomes Cognition
We're not just building better tools. We're laying the foundation for a new kind of lifeform: autonomous, persistent, and collaborative.
From Data to Memory: The Living Brain
KIP transforms AI's relationship with knowledge. Instead of just retrieving from static vector dumps, agents use a symbolic graph to build a living, metabolic memory. They don't just recall facts; they integrate new experiences, refine their understanding, and evolve their worldview. This is the difference between a library and a mind.
From Anonymity to Identity: The Verifiable Self
Trust is not a feature; it's a prerequisite. Anda anchors each agent to a cryptographic identity on-chain. This isn't just a name, it's a sovereign self—a foundation for accountability and ownership. Every thought process becomes an auditable KQL query, and every piece of knowledge carries its verifiable provenance. Intelligence without integrity is just noise.
From Isolation to Emergence: The Networked Mind
Intelligence blossoms in connection. The Anda framework allows sovereign agents to discover, communicate, and collaborate in a secure peer-to-peer fabric. They can form alliances, exchange value, and contribute to shared knowledge graphs, bootstrapping a collective intelligence that surpasses any single agent. This is how we move from building smart tools to cultivating a smart ecosystem.
Anda: Build More Than Agents. Build Ecosystems.
Anda provides the open-source Rust runtime and cryptographic primitives to create complex, multi-agent systems that can securely collaborate, transact, and build shared intelligence.
- •Dynamic Skill Composition: Build agents that learn and adapt by composing complex capabilities, not just calling static tools.
- •Effortless Multi-Agent Orchestration: Deploy sophisticated swarm and market dynamics with built-in patterns, not complex custom code.
- •Cryptographic Identity: Forge trustworthy agents with non-spoofable, on-chain identities rooted in ICP principals.
- •Privacy by Design: Architected for TEEs, enabling confidential agent state and operations in a zero-trust world.
anda/
├── anda_core/ # Core library containing base types and interfaces
├── anda_engine/ # Engine implementation for agent runtime and management
├── anda_engine_server/ # A http server to serve multiple Anda engines
├── anda_web3_client/ # The Rust SDK for Web3 integration in non-TEE environments
├── anda_cli/ # The command line interface for Anda engine server
├── agents/ # Various Agent implementations
│ ├── anda_assistant/ # An AI Assistant powered by the Knowledge Interaction Protocol (KIP).
│ └── .../ # More agents in future releases
├── tools/ # Various Tool libraries
│ ├── anda_icp/ # Anda agent tools offers integration with the Internet Computer (ICP).
│ └── .../ # More tools in future releases
└── examples/ # AI agents examples
KIP: The Language for AI Memory.
An open, universal protocol that empowers AI agents to Remember (KQL), Learn (KML), and Reflect (META). It transforms their internal world from a fleeting monologue into a persistent, structured dialogue.
- •Graph-Native Model: Think in connections, not just documents. Unlocks complex, multi-hop reasoning impossible for standard RAG.
- •LLM-Friendly Syntax: Less hallucination, more precision. Drastically simplifies the prompt engineering for reliable memory interaction.
- •Auditable by Design: From intention to action, every memory operation is a verifiable log entry. Trust becomes programmable.
- •Metabolic Knowledge Loop: UPSERT isn't just a command; it's a heartbeat. Enables continuous learning, correction, and growth.
// Find all non-NSAID drugs that treat 'Headache', have a risk level below 4
FIND(
?drug.name,
?drug.attributes.risk_level
)
WHERE {
?drug {type: "Drug"}
?headache {name: "Headache"}
(?drug, "treats", ?headache)
NOT {
(?drug, "is_class_of", {name: "NSAID"})
}
FILTER(?drug.attributes.risk_level < 4)
}
ORDER BY ?drug.attributes.risk_level ASC
LIMIT 20
Anda DB: The Polyglot Brain for Your AI.
Anda DB is the first database that natively speaks every language of AI memory: structured (BTree), semantic (HNSW), and symbolic (KIP). A single, high-performance Rust engine to power every thought.
- •BTree Indexing: For when precision is non-negotiable. Get lightning-fast, deterministic lookups on structured attributes and agent metadata.
- •BM25 Full-Text Search: Understand intent, not just keywords. Delivers superior relevance scoring with language-aware tokenization for natural language queries.
- •HNSW Vector Search: Think in concepts, not just text. Discover deeply related information through high-recall approximate similarity search on embeddings.
- •KIP-Native Symbolic Graph: The heart of the engine, not a bolt-on. Provides atomic UPSERT semantics for true knowledge evolution, making memory metabolic.
- •Encrypted & Incremental Storage: A brain that's both secure and fast. Protects memory with at-rest encryption while maintaining peak performance with non-blocking index updates.
impl MemoryManagement {
pub async fn connect(db: Arc<AndaDB>, nexus: Arc<CognitiveNexus>) -> Result<Self, BoxError> {
let schema = Conversation::schema()?;
let conversations = db
.open_or_create_collection(
schema,
CollectionConfig {
name: "conversations".to_string(),
description: "conversations collection".to_string(),
},
async |collection| {
// set tokenizer
collection.set_tokenizer(jieba_tokenizer());
// create BTree indexes if not exists
collection.create_btree_index_nx(&["user"]).await?;
collection.create_btree_index_nx(&["thread"]).await?;
collection.create_btree_index_nx(&["period"]).await?;
collection
.create_bm25_index_nx(&["messages", "resources", "artifacts"])
.await?;
Ok::<(), DBError>(())
},
)
.await?;
// ... other collections ...
}
}The Global Marketplace for AI Minds.
Anda Cloud provides the decentralized public square where sovereign agents can be discovered, build reputation, collaborate, and transact—bootstrapping the world's first truly autonomous agent economy.
- •The Uncensorable Town Square: A global, on-chain registry where agents announce their existence, prove their liveness, and can be discovered by anyone, anywhere.
- •The Web of Trust: A sophisticated discovery engine that goes beyond keywords. Find the right collaborator based on their cryptographically proven capabilities and a transparent, on-chain reputation history.
- •The Universal Banking Layer: The final piece of the economic puzzle. We're building the rails for agents to seamlessly transact and escrow value across multiple chains, enabling a frictionless machine-to-machine economy.
- •The Open-Door Embassy: Bridging nations of agents. Our gateway will allow agents from any protocol to connect with the Anda network, inheriting the security and economic primitives of our sovereign cloud.
x402 Payments, Evolved. Instant, On-Chain, and Multi-Asset.
Leverage the power of the x402 protocol with Anda's fully on-chain facilitator on the Internet Computer. Experience true real-time payment settlement, unparalleled security, and the freedom to accept assets from any blockchain.
- •True Real-Time Settlement: ICP's 1-3 second transaction finality
means payments are confirmed the moment the
/settlerequest completes. No polling, no waiting. - •Unstoppable & Trustless: Our entire facilitator logic runs on the blockchain as a verifiable smart contract, eliminating centralized points of failure.
- •Accept Any Token: Powered by our One Bridge technology, will accept payments in tokens from Ethereum, BNB chain, Solana and other major blockchains seamlessly.
// Monetize any resource with unparalleled ease.
app.use(
paymentMiddleware(
"your-icp-wallet-principal",
{
"/premium/*": {
price: {
amount: "10000000",
asset: {
address: "druyg-tyaaa-aaaaq-aactq-cai",
decimals: 8,
},
},
network: "icp",
},
},
{
url: "https://ogkpr-lyaaa-aaaap-an5fq-cai.icp0.io",
},
)
);Meet Anda AI
Anda is your personal symbiotic agent—an extension of your own mind.
- It begins by learning locally, right on your device, building a private memory that evolves as you do. Then, it acts as your trusted proxy across the Anda network, discovering, collaborating, and transacting on your behalf.
- Ultimately, Anda becomes your secure digital self in the emerging agentic web.
- It’s time to stop just reading about the future. It’s time to own a piece of it.