Multiplayer memory.
Govern and unify memory across your entire agent workforce. Oiya integrates with per-agent memory providers like Mem0, Zep and Flumes, and adds the organisational layer on top: governed knowledge, consistent definitions and cross-agent alignment.

The problem
You built one agent. It works. It has some memory: maybe a vector store, maybe a file it reads on startup. Good enough for a prototype.
Then you build a second agent. And a third. Suddenly you have a BD agent that knows about Acme Corp's acquisition, a support copilot that doesn't, and an HR agent that thinks "qualified" still means what it meant six months ago. Each agent develops its own understanding of the company. Different definitions, different sources, different versions of the truth.
Per-agent memory doesn't scale. What you need is infrastructure that lets agents share what they learn, without losing control of what they know. That shared layer is not chat history. It is a graph of the users, accounts, definitions and decisions each permitted agent can work from.
Scale
From one agent to a thousand
Oiya is designed to grow with you. Start with a single agent reading from the knowledge graph during development. Ship to production with dozens of agents across teams and geographies. Scale to hundreds, each scoped to exactly the knowledge it needs.
Every agent gets its own partition, a self-sustaining slice of the graph. Agents in the same partition share context automatically. Agents in different partitions stay isolated until you decide otherwise. The architecture doesn't change as you grow. You just add more partitions.
Same architecture at 1 agent and at 1,000.

Integration
Works with any agent
Oiya isn't a framework. It's infrastructure. Bring your own agent stack. We'll give it memory.
Python library
Install the Oiya SDK, point it at your knowledge backend, and your agent can query the full graph. Reading context, proposing new facts, searching entities. It's one function call each.
client = KnowledgeClient()
context = client.get_context(agent_id)
Claude Skill
Already using Claude? We ship as a native Claude Skill. Your agent gets structured knowledge as part of its tool palette, no wrapper code, no middleware. Just plug in and query.
Works with any agent framework that supports tool calling: LangChain, CrewAI, OpenAI Agents SDK, smolagents, or your own.
Works alongside Mem0, Zep and Flumes
Already using a per-agent memory provider like Mem0, Zep or Flumes? Keep it. Add an "insights" tool call and your agent starts sharing what it learns with the rest of the organisation through Oiya's governed knowledge layer. Per-agent memory keeps handling session continuity; Oiya handles cross-agent alignment.
Your memory, now shared.
Ontology Engineer
Meet Marty, your ontology engineer
You shouldn't need a knowledge engineer to keep your agents informed. Oiya includes an Ontology Engineer agent that handles the heavy lifting: mapping new agents to the right partitions, assigning schema access, and configuring what each agent can read, write, and propose.
Point it at a new agent and tell it what the agent does. The Ontology Engineer will suggest the right knowledge partitions, set sensible defaults for schema access, and walk you through the rest. It guides you through updating the ontology as your organisation evolves: new teams, new domains, new agents.
Guided, not magic.

How it works
You want flexibility for an agent to learn its own domain, but surface insights that might be relevant for the organisation as a whole. With total control.
Knowledge graph
At the core is a structured knowledge graph: entities, relationships, definitions, workflows. All typed, all queryable. When your agent asks "who are our top clients in EMEA?", it gets a real answer from a real schema. Not a similarity search across embeddings.

Partitioned by design
The graph is partitioned. Each partition is a self-sustaining slice. You can put one agent or many into a partition. Agents in "Client: Retail" share context automatically. They never see HR data they shouldn't. The graph shapes itself around your boundaries.

Agents learn in their space
Every conversation is a chance to capture new knowledge. A support call reveals that "qualified" now means something different. A BD agent discovers Acme Corp just acquired a competitor. These insights are captured as structured facts within the agent's partition.

Agents propose. Humans approve.
When an agent learns something that could matter beyond its partition, it proposes the change. Proposals carry confidence scores. High-confidence, low-sensitivity updates get auto-approved. Structural changes queue for human review. You set the thresholds.


Scalability
Built for production
Run the knowledge graph on-prem or in your own cloud. Your data never leaves your infrastructure. From a single agent reading facts during development to thousands in production, the same deployment, the same API.
For each individual agent, the knowledge graph works like a fact-based file system. You can search through it just like any other memory tool: by keyword, by entity, by relationship. It doesn't replace your existing memory. It includes it. The graph is the superset: structured facts, versioned schema, and full-text search all in one layer.
Your infrastructure. Your data. Our graph.
Boundaries
Shared knowledge does not mean unrestricted access.
Agent-specific memory can remain local to each system. Oiya manages the organisational knowledge that agents need to share, while allowing teams to define boundaries around which knowledge each agent can access.
This is especially important when systems handle multiple customers, departments or categories of sensitive information.
Ready to make memory multiplayer?
See how Oiya gives your agents shared context, governed learning, and a knowledge graph that scales with your organisation.
Explore more
Knowledge Management
Versioned, governed, observable memory for your agents.
Data Fabric
A directory of data sources so agents stop wandering.
Integrations
Connect to everything your team already uses.
vs Zep / Graphiti
From personal memory to company knowledge.
For AI Engineers
Multiplayer memory with version control and scoped access.