The Control Plane for Agent Memory
You're building AI agents across the company. Marketing has one. Sales has three. HR is piloting two more. Each one needs context about who your clients are, what your products do, what 'qualified' actually means. Oiya is the shared infrastructure layer: a single knowledge server that every agent reads from, writes to, and versions against.

Two components. That's the whole system.
Most knowledge infrastructure comes with a glossary of abstractions before you can write your first query. Oiya has two moving parts. Once you understand them, you understand the entire deployment.
The Knowledge Server
A Go binary with a REST API, a CLI, and a web dashboard. It stores your company's structured knowledge: entity types, relationships, facts, and the schema that ties them together. Your agents connect to it over HTTP. That's the integration. No sidecar processes. No embedded databases per agent. One server, many partitions, one shared knowledge layer.
Deploy it once. Let every team connect.
Our Custom Models
When new information arrives (from a website crawl, a CRM sync, a conversation transcript), our models handle extraction, classification, and schema evolution. You don't wire up prompt chains or manage embedding pipelines. The models understand ontology structure natively. They know what an entity type is, what a relationship means, how a fact should be grounded.
Extraction that understands structure, not just text.
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. Think of it like a pull request for your knowledge base.
High-confidence, low-sensitivity changes can 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.


Evals
Evals are infrastructure, not afterthoughts.
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 dashboard you check quarterly. It's how you catch drift before your agents do. When "qualified" means something different in the sales partition and the HR partition, the grounding score drops and the eval tells you exactly where. Fix the concept definition, not the prompt.
Guided, not magic.
Scalability
One server. Then ten.
The Go knowledge server is your single deployment target. You don't operate a graph database, a vector store, and a middleware layer separately. You run one binary. It exposes a REST API for programmatic management, a web interface for domain experts who want to browse the graph, and a CLI for adding knowledge from the terminal: oiya teach, not a twelve-tab wizard.
Start with a single instance. As you add more agents, partition by team, by client, by domain. Each partition is an isolation boundary. Your BD agent sees retail clients, your ops agent sees finance, but they both agree on what "delivery SLA" means because the definition lives in the shared schema. When you need to scale, shard partitions across nodes or increase resources on the knowledge server. The architecture doesn't change. Horizontal scaling follows partition boundaries naturally. They were designed as the unit of isolation and the unit of scaling from day one.
One deployment. Every team connects. Scale when you need to.


Management
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. 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.
Permissions at the knowledge layer, not the prompt layer.
51 sources. One ingestion layer.
Connect websites, CRM exports, SQL databases, Google Drive folders, Jira boards, conversation transcripts. Each source gets a sync status, access level, and audit trail. When a source updates, the knowledge server re-extracts, re-classifies, and surfaces proposals for anything that changed. You see what came in, where it landed, and whether it matters.
Team self-service, central oversight.

Build once. Let every team build on top.
Oiya is open source. Clone the repo, deploy the knowledge server, and have your first agent reading from a versioned, evaluated knowledge graph in under ten minutes.
Explore more
For AI Engineers
Multiplayer memory with version control and scoped access.
For Engineering Leaders
Keep LLMs on-track with versioned, observable memory.
Integrations
Connect to the tools your team already uses.
Data Fabric
A directory of data sources so agents stop wandering.
Product Overview
See the full picture of what Oiya does.