Multiplayer Memory
You've built agents that remember. Now you need agents that remember together, with version control, token budgets, and scoped access you can actually reason about. This is the infrastructure layer.

Two concepts. That's it.
Most knowledge infra introduces a glossary before you can write your first query. Oiya has two primitives. Once you understand them, you understand the whole system.
Partition
A partition is a slice of the knowledge graph that an agent has access to. Think of it like a schema in a database. It defines the boundary of what an agent can read, query, and propose changes to. An agent scoped to "Client: Retail" will never accidentally surface HR compensation data. Partitions are the unit of isolation, and they're the unit of scaling.
One agent per partition, or fifty. The boundary stays clean.
Space
A space is where an agent lives and learns. It contains the agent's assigned partition of the ontology: the structured facts, entity types, and relationships, plus a simple memory layer if the agent uses one. Spaces are how you give an agent both shared organisational context and its own working memory without tangling the two.
Shared context + private memory, in one address.
Versioning
Knowledge has commits
Every fact in the graph is versioned. When an agent learns that Acme Corp just acquired a competitor, that doesn't silently overwrite what was there before. It creates a proposal with a confidence score, source provenance, and an impact preview, like a pull request for your knowledge base.
High-confidence, low-sensitivity changes auto-merge. Structural changes (new entity types, schema modifications, partition reassignments) queue for human review. You set the thresholds. The system version increments on every accepted batch, and you can trace any fact back to the conversation or document that introduced it.
Auditable by default, not by afterthought.


Token Budgets
You see the cost before the call
Every partition shows its token count. Right there in the UI, before your agent makes a single LLM call. You know exactly how much context each slice of the graph will consume: 3,566 tokens for the full organisation, or a few hundred for a tightly scoped client partition.
This matters when you're running agents at scale. Context windows aren't infinite, and stuffing everything into a system prompt is how you get hallucinations and blown budgets. Oiya lets you reason about token cost the same way you reason about memory allocation: per partition, per agent, before runtime.
Context is a budget. Treat it like one.
Engineering Workflow
Teach from the terminal
The UI is for domain experts. You live in the terminal. Oiya ships a CLI for teaching your organisation's concepts directly: define entity types, set up partitions, assign agents, and push schema changes without leaving your editor. It's oiya teach, not a twelve-tab wizard.
For managing the full cluster (spinning up new partitions, reviewing proposals across agents, bulk-approving schema updates), Claude Code works as a first-class management interface. Point it at your Oiya instance and it understands the graph. You manage infrastructure the same way you build with it: conversationally.
Your workflow. Your tools. Our graph.


Agent Registry
Every agent, accounted for
Register agents with a role, a description, and a set of partition assignments. The BD Agent reads from Core and Client: Retail. The HR Agent is scoped to HR Core. Claude gets the default partition plus whatever you grant. Each agent can propose changes but none can approve their own. That's a human decision, or an auto-approval rule you've configured.
The registry isn't just for visibility. It's how the system enforces access control at the knowledge layer. When your support agent asks about placement metrics, it either has access to that partition or it doesn't. No prompt engineering required. The boundary is structural.
Permissions at the knowledge layer, not the prompt layer.
Eval
Measure the graph, not vibes
Oiya scores your ontology across eight dimensions: extractability, precision, grounding, safety, stability, operationality, composability, and interpretability. Each score comes with actionable suggestions: add extraction hints for ambiguous entity types, set canonical IDs for top-level concepts, define cardinality on relationships.
This isn't a vanity dashboard. It's how you catch drift before your agents do. When "qualified" means something different in two partitions, the grounding score drops and the eval tells you exactly where. Fix the concept, not the prompt.
Guided, not magic.

Ship agents that share what they know.
Oiya is open source. Clone the repo, spin up the knowledge backend, and have your first agent reading from a versioned knowledge graph in under ten minutes.