Multiplayer memory

    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.

    Oiya knowledge graph showing domain partitions, active agents, and pending changes across the organisation

    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.

    Agent management dashboard showing BD Agent, Support Agent, HR Agent and Claude each assigned to specific partitions

    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.

    from oiya import KnowledgeClient
    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.

    Ontology Engineer interface showing agent onboarding with partition assignment and schema access controls

    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.

    1

    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.

    Knowledge graph visualization showing entity relationships
    2

    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.

    Domain partitions showing concept counts and agent assignments
    3

    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.

    Grounded concept library with quality scores and relationship counts
    4

    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.

    Proposals dashboard with confidence-scored changes pending review
    Sources dashboard showing connected integrations, documents, CRM feeds, and database connections

    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.

    Security and deployment

    Ready to make memory multiplayer?

    See how Oiya gives your agents shared context, governed learning, and a knowledge graph that scales with your organisation.