Competitor analysis

IOBOXX plays in AI memory infrastructure — the category currently occupied by Mem0, Zep, Letta, Cognee, and a handful of academic projects. The customer is the developer building AI agents who needs persistent, queryable, structured memory that survives sessions, scales with the agent’s interactions, and is reasoned over by the agent itself via tools. This page is the long-form companion to the comparison strip on the home page: same eight rows, with the evidence behind each claim.

SUMMARYEight differentiators at a glance

Each row below expands the claim with the load-bearing evidence — what we do, what the field does, and why the gap is structural rather than a roadmap item the competitors will close next quarter.

01Portable across LLMs (open MCP)

IOBOXX speaks MCP at the protocol boundary. Any MCP-aware agent — Claude Code, Cursor, ChatGPT, your own — can read and write IOBOXX memory; any frontier model can drive that agent. Mem0, Zep, Letta, and Cognee bind to their own SDKs and REST APIs: switching the model is fine, but switching the memory layer means rewriting your integration. Switch the model, keep the memory — see /docs/architecture/memory/portability for the architectural shape.

02Senses as graph extension (N → 1 / 1 → N)

An integration imports rows from an upstream system into a staging table. A sense does something different: it extends the agent’s working memory into the upstream system as a traversable node in the same graph. A Stripe charge, a Salesforce contact, a workflow stage — one graph walk, four systems, no duplicate copy. No competitor encodes the N → 1 / 1 → N topology as a first-class architectural primitive; they all treat upstream systems as ETL sources, not as memory extensions. See /docs/architecture/senses.

03Agent-defined schema

A Fundi creates a new type at runtime by calling define_object_type; it adds a field with add_field_to_type. No code deployment, no developer pull request, no migration. The schema is itself data (`__TypeDef` + `__FieldDef` rows in the Object Store), so the agents writing memory are the same agents defining its shape. Every competitor takes the opposite path: Mem0 stores flat text strings, Letta has developer-defined memory blocks, Zep extracts entities against a fixed ontology, Cognee runs an LLM extraction pipeline against pre-declared types. The working-memory flywheel proof — 106K-document corpus collapsed to 84 typed objects across 14 types in two passes — is in the wiki at `architecture/memory/object-store/20-working-memory-flywheel.md`.

04Per-twin sovereignty

Each twin is its own blast radius — a dedicated Object Store instance with its own OpenFGA model. Process-level isolation, not row-level filtering with hopeful guards in application code. A FORUS Digital admin is not automatically an IOBOXX admin; compromise of one tenant cannot escalate to a neighbour. Mem0, Zep, and Letta all assume a single tenant or row-level multi-tenancy. None of them survive a regulatory audit for “what happens if tenant A’s admin tries to read tenant B’s data.” See /docs/architecture/mycelium.

05Deterministic log

Every reducer call appends a hash-chained, deterministic commit entry. Two instances starting from the same state and processing the same calls arrive at byte-identical state. An external party with a copy of the commitlog can verify exactly what happened, when, by whom, with what effects — replayable disputes, regulator-grade audit, reproducible state. Most agent-memory projects layer on top of LLM-driven nondeterministic transformations (extract entities, embed text, summarise) and call the result “memory.” IOBOXX commits to the log as the source of truth and treats LLM calls as side-effects on that substrate.

06Mycelium

Twins exchange through the IOBOXX mycelium — explicit, directional, permissioned cross-twin grants modelled in OpenFGA, routed through a hub-and-spoke shared ledger, never an N × N integration topology. Adding a new consumer twin requires zero work in the source twin: CSP grants a slice to the FDA twin, ECA grants a slice to the FDA twin, a hospital twin grants a slice to the FDA twin, and nothing in FDA changes. Knowledge graphs federate as a research topic; IOBOXX ships the same primitive as a product feature, named for what it actually is — a mycelium of sovereign organisms exchanging through directional hyphae. The closest comparable primitives — Solid for personal data pods, Gaia-X for industrial data spaces — target different categories entirely.

07Tensor substrate

Memory and model share the same primitive. A node attribute map is a sparse tensor row: rows are object ids, columns are attribute slots, values are scalars or embedding vectors. There is no impedance mismatch between the memory layer and the model layer. Every other system stacks property-graph-over-relational-DB-over-disk and serialises at each crossing — three encodings, three caches, three failure modes. See /docs/architecture/memory/tensor-as-substrate for the substrate argument.

08Contribution attribution

The commitlog drives on-chain settlement via 0xSplits and Superfluid on Base. AI agents and humans are economic peers, both with wallets, both addressable as actors in tenant workflows. ElizaOS has a token but no attribution; Mem0, Zep, and Letta have neither. Virtuals has agent economics ($470M aGDP) but no memory substrate, no BPMN governance, and no emerging-market path. IOBOXX combines all three with the deterministic commitlog as the supply-side proof.

WHITE SPACESThe six structural gaps in the field

The panel research that produced this analysis identified five white spaces in the competitive landscape; the techstack positioning thesis adds a sixth. Each is an arrangement of capabilities that exists nowhere else, and the combination is load-bearing for the substrate IOBOXX is building.

• Cooperative economics. No agent platform uses a cooperative distribution model; all use SaaS subscriptions.
• Human–AI economic equivalence. Agents earn elsewhere but never as cooperative members alongside humans on the same rails.
• Agent-defined memory schemas. No other system lets agents create types and evolve fields at runtime.
• Emerging-market distribution. Every platform is US/EU SaaS; no localised, mobile-first, mobile-money-aware workflow substrate exists.
• Auditable attribution. The commitlog traces every contribution to every object; most agent systems are opaque.
• Sovereign distributed memory. The sixth white space the techstack positioning thesis adds — per-twin sovereignty, federation primitives, and the N → 1 / 1 → N senses model as one coherent architecture.

See /docs/strategy/the-name for the philosophical framing of why these six differentiators are an axis rather than a feature list.

BOUNDARYWhat IOBOXX deliberately does not compete with

The category line matters as much as the differentiators. The techstack positioning thesis is explicit about where IOBOXX is not playing — these are not future markets, they are permanent non-goals that keep the substrate focused.

• Workflow tools (n8n, Dify, Zapier, Make) — BPMN is a load-bearing primitive, not the product. We do not compete in the visual workflow builder market.
• Vector databases (Pinecone, Weaviate, Qdrant, Chroma) — embeddings live inside the Object Store alongside typed objects, not as a standalone vector store.
• General-purpose chat platforms (Slack, Discord, Teams) — chat materialises as Object Store working memory, not as a standalone messaging product.
• DAO platforms / token launchpads (Aragon, DAOhaus) — the IOBOX token is for contribution attribution, not a platform for other tokens to launch on.
• DeFi protocols (Aave, Compound, Uniswap) — the token exists for attribution, not yield.
• Cloud LLM APIs (OpenAI, Anthropic, Google) — IOBOXX consumes these as dependencies; it does not compete with them.
• Identity providers (Auth0, Okta, WorkOS, Stytch) — IOBOXX uses Keycloak as its upstream IdP; it does not compete with IdP-as-a-service.
• No-code app builders (Bubble, Retool, Internal) — IOBOXX is infrastructure for developers and Fundis, not a no-code surface.

In one paragraph

IOBOXX is the only AI memory substrate that combines open-MCP portability, senses-as-graph-extension topology, agent-defined schemas, process-level per-twin sovereignty, deterministic state, federation primitives, a tensor substrate, and on-chain contribution attribution. Any one of these alone exists somewhere else in partial form. The combination is the moat — and it’s the moat because the combination is load-bearing for the actual use case: sovereign working memory for multi-agent systems where humans observe Fundi reasoning in real time and take over at any point.