The interoperability hub for the Internet of AI
The memory layer under autonomous agents has split in two: local-first and cryptographic on one side, cloud-coordinated on the other. ai4all takes no side. It is the routing seam between them — one Model Context Protocol surface, twenty backends, and a firewall that runs before anything executes.
- memory networks
- 20
- protocol pillars
- 7
- engineering stages
- 5
Hover a node · inner ring sovereign · outer ring cloud
- Vana — sovereign circle — Local store over stdio — User-owned data DAOs; the wallet signs before the model reads.
- Silmari — sovereign circle — Local store over stdio — Active forgetting as a first-class primitive, executed on device.
- Personal AI — sovereign circle — Hybrid over stdio — A personal language model trained on one person's own corpus.
- Rewind — sovereign circle — Capture stream over stdio — Continuous local capture of everything seen, said, and heard.
- Tenure — sovereign circle — Local store over stdio — Durable local memory tenure without a cloud round-trip.
- MemTrust — sovereign circle — Structured graph over stdio — Attested memory: every recall carries a verifiable provenance chain.
- Dina — sovereign circle — Structured graph over stdio — Credentialing and proof-of-competence issuance for agents and humans.
- OpenMemory — sovereign circle — Flat vector over stdio — Open-source, self-hosted memory layer shared across local agents.
- Mem0 — non-sovereign circle — Flat vector over http-stream — Fast flat-vector memory with ultra-low read latency.
- Letta — non-sovereign circle — Hybrid over http-stream — OS-style virtual memory paging for long-lived agents.
- Wispr Flow — non-sovereign circle — Capture stream over http-stream — Voice-first capture that turns speech into structured context.
- Zep — non-sovereign circle — Structured graph over http-stream — Bi-temporal knowledge graph; facts carry valid-time and ingest-time.
- Cognee — non-sovereign circle — Structured graph over http-stream — ECL pipelines that cook raw documents into a queryable memory graph.
- Hypabase — non-sovereign circle — Structured graph over http-stream — Hyperedge indexing for dense, multi-role facts.
- Memanto — non-sovereign circle — Flat vector over http-stream — Flat-vector recall tuned for rapid, zero-ceremony ingestion.
- A-MEM — non-sovereign circle — Structured graph over http-stream — Agentic memory that reorganises its own note network over time.
- Hindsight — non-sovereign circle — Hybrid over http-stream — Retrospective reasoning over what the agent already did.
- Theoria — non-sovereign circle — Structured graph over http-stream — Hypothesis-shaped memory for multi-agent research workflows.
- Granola — non-sovereign circle — Capture stream over http-stream — Meeting context that survives the meeting.
- Touchy — non-sovereign circle — Flat vector over http-stream — Relationship memory: who, when, and what was promised.
Protocols the host speaks
- Model Context Protocol — Anthropic — Protocol baseline
- HyperCycle — HyperCycle — Ledgerless settlement rails
- A2A — Google / Linux Foundation — Agent-to-agent translation
- AGNTCY — Cisco and collaborators — Orchestration matrix
- NANDA — MIT — Resource allocation and discovery
- ACP — IBM / Linux Foundation — Agent communication
- Linux Foundation — Linux Foundation — Open governance
The shift
From the read-path web to the write-path web
The traditional web was built for human pedestrians: we click, we read, we scroll. Agents that negotiate, execute, and transact need something else — and they cannot be let loose on human infrastructure without boundaries.
Legacy intranet of AI
- Brittle DOM scraping against interfaces built for eyes.
- Walled gardens, each with its own auth and its own schema.
- Context fragmented across tools that cannot see each other.
The Internet of AI
- Agentic delegates calling declared capabilities, not guessing at markup.
- Stateful multi-step workflows that survive the session.
- Peer-to-peer semantic routing across heterogeneous backends.
Position
Not a wrapper. A runtime seam.
ai4all sits between the applications people build and the execution substrate underneath, providing the vault and the connectivity matrix so a credible business can plug into the Internet of AI without building the whole stack itself. As a designated executor entity in the Mosaic ecosystem, that seam is the product.
Neutrality
The interoperability membrane
Twenty memory and user-intelligence networks, split across two architectural philosophies. ai4all is the bridge — users pick their side, and the routing layer absorbs the difference.
The memory sector has bifurcated. A hub that picks a winner is just another walled garden — so the routing seam addresses both sides through one session.
Request path
Automated secure connectivity across the stack
Every call takes the same four steps, and every step is inspectable.
- STEP 01
Ingestion
An application submits a multi-step request. It arrives as a self-describing payload — no session to resume.
- STEP 02
Translation
The request is normalised through the Model Context Protocol: JSON-RPC 2.0 envelope, declared tool schema, typed arguments.
- STEP 03
Orchestration
The hub resolves which backends can answer, translating between flat-vector and graph schemas, alongside A2A and AGNTCY routing.
- STEP 04
Settlement
Usage settles peer-to-peer over TODA/IP rails, with the receipt carried in the response rather than written to a shared ledger.
Hardened runtime
The brain never touches the hands
ai4all ingests third-party plugins without a trust hand-off escape. The reasoning engine is architecturally severed from the execution environment, so compromising an executor does not reach the model's context, credentials, or decision loop.
Pre-execution firewall
Intercepts, audits, and permissions every request before a runtime exists. Schema assertion first, argument inspection second, spawn last.
microVM containment
External tools and adapters run behind a hardware-virtualised boundary with their own guest kernel — not a shared one.
Cryptographic erasure
Ephemeral volumes mount per session and lose their keys at the end of it, so nothing durable survives into the next.
Roadmap
Five stages, honestly labelled
Stage 1 is this portal and the sandbox you can use today. Everything after it is engineering work we intend to do — stated as intent, not as shipped capability.
- STAGE 1Live
Launch Portal & WebMCP Playground
Establish the visual identity, publish the developer manuals, and ship an interactive WebMCP test surface.
- STAGE 2Next
Stateless Host Engine & Pre-Execution Firewall
Build a stateless host that ingests, parses, and verifies incoming tool-call payloads before anything executes.
- STAGE 3Planned
Parallax Paradigm Execution Layer
Physically isolate executing plugin runtimes from the host's reasoning environment.
- STAGE 4Planned
Ledgerless Settlement Gateway
Settle peer-to-peer usage without a shared ledger and without third-party gas fees.
- STAGE 5Planned
Swarm Integration & Distributed Nodes
Connect the runtime to A2A and AGNTCY routing, then push stateless coordination nodes to the edge — and eventually beyond it.
Build on the seam
Send your first tool call through the host
The sandbox runs the real request path in your browser — parse, envelope, schema, firewall, sandbox, settlement. Try a valid payload, then try a hostile one and watch where it stops.