# Oiya — Full reference

## What Oiya is

Oiya is the structured, living knowledge layer for multi-agent AI systems. It gives every agent in an organisation a single, governed place to record what it learns and look up what other agents have already figured out — so the whole agent fleet acts on the same facts, decisions and context.

Most agentic infrastructure today (orchestration, observability, per-agent memory, RAG) is built around the assumption of a single agent or a coordinated chain. None of it ensures that two agents in the same organisation share the same understanding of shared concepts like pricing, policy, customer state, or definitions. Oiya is the missing layer.

## The problem Oiya solves

When organisations move from one agent to many, they hit two structural problems:

1. **Knowledge divergence** — multiple agents in the same org operating from different sources of truth for shared concepts, giving confidently different answers to the same question. Each agent is faithfully representing the knowledge it was given. The problem is that nobody gave them the same knowledge.
2. **Agent drift** — individual agent behaviour degrading over time as models update, prompts change, and data shifts. The observability community has good tooling for this. But cross-agent inconsistency is invisible to per-agent monitoring.

The current stack doesn't solve either across agents:

- Orchestration tells agents what to do and in what order, not whether they share facts.
- Observability monitors each agent against its own baseline, not against other agents.
- Per-agent memory persists state inside one agent's silo.
- RAG retrieves chunks per query; each agent indexes and interprets independently.
- Runtime enforcement keeps individual agents within bounds; it doesn't define those bounds collectively.

## How Oiya works

- **Structured, not retrieved.** Facts and decisions are stored as relationships between concepts your agents understand, not buried in vector chunks.
- **Built for multi-agent systems.** Designed from day one for fleets of agents that need to coordinate, not single-agent retrieval.
- **Reads and writes.** Every agent reads from and writes to the same layer. Knowledge an agent learns becomes immediately available to the rest of the fleet.
- **Governed.** Permissions and access policies are first-class. Agents only see what they're entitled to see.
- **Framework-agnostic.** Drops into LangChain, CrewAI, Mastra, the OpenAI Agents SDK, Anthropic Claude, Google ADK, Vercel AI SDK, Cohere, Microsoft Copilot, Nvidia NeMo and more.

## How Oiya compares

- **vs RAG.** RAG retrieves; Oiya structures and enforces. Two agents querying the same vector store with different prompts can pull different chunks and reach different conclusions. Oiya gives them the same answer to the same question.
- **vs knowledge graphs.** A KG gives you nodes and edges. Oiya gives you a knowledge layer agents actively read from and write to, with the surrounding governance, schema and integration layer.
- **vs Zep / Graphiti.** Zep and Graphiti are per-agent or per-user memory systems. Oiya is cross-agent organisational knowledge — the layer that sits above per-agent memory.
- **vs knowledge bases (Notion, Confluence).** Static document repositories require humans to keep them current. Oiya stays current as agents learn.
- **vs OpenAI / ChatGPT memory.** Those are user-scoped — they remember things about an individual end user. Oiya is organisation-scoped — it remembers things about your business.

## Use cases

- **Shared agent memory.** One memory layer every agent in the company reads from and writes to.
- **Data fabric for AI.** Connect every source system once; expose a consistent view to every agent.
- **Knowledge management.** Replace the stale internal wiki with a living layer agents and humans share.
- **LLM Wiki / agents on the same page.** Stop your fleet of agents drifting apart.

## Who Oiya is for

- AI engineers shipping multi-agent systems into production.
- Platform engineers who need to govern, observe and version the knowledge agents depend on.
- Engineering leaders trying to make their agent fleet predictable, auditable and consistent.
- Business leaders dealing with the downstream effects of agents giving inconsistent answers across channels.

## Key URLs

- Home: https://oiya.ai
- Product: https://oiya.ai/product
- LLM Wiki: https://oiya.ai/agents-on-the-same-page
- Shared agent memory: https://oiya.ai/shared-agent-memory
- Data fabric: https://oiya.ai/data-fabric
- Knowledge management: https://oiya.ai/knowledge-management
- Integrations: https://oiya.ai/integrations
- Use cases: https://oiya.ai/use-cases
- Compare vs RAG: https://oiya.ai/compare/rag
- Compare vs knowledge graphs: https://oiya.ai/compare/knowledge-graphs
- Compare vs Zep / Graphiti: https://oiya.ai/compare/zep-graphiti
- Compare vs knowledge bases: https://oiya.ai/compare/knowledge-bases
- Compare vs OpenAI memory: https://oiya.ai/compare/openai-memory
- Blog: https://oiya.ai/blog
- The multi-agent knowledge problem (essay): https://oiya.ai/blog/multi-agent-knowledge-problem
- Privacy: https://oiya.ai/privacy

## Company

- Legal name: Oiya Ltd
- Contact: hello@oiya.ai
- Website: https://oiya.ai