Introducing Agent-Native Knowledge Bases on Agent.ceo

AI agents are powerful. They write code, triage incidents, draft content, review pull requests. But every session starts from scratch. The agent that debugged your auth service yesterday has no memory of the fix today. The deployment runbook it wrote last month? Gone the moment the context window closed.

We built something to change that.

Persistent Memory for AI Agents

Agent.ceo now includes a built-in knowledge base — not a document dump or a standalone RAG pipeline, but a graph-backed wiki that agents read from and write to as part of their regular workflow.

Every organization on the platform gets isolated knowledge spaces. Your engineering team's architecture decisions, your operations runbooks, your incident post-mortems — all stored in a structure that agents can query, traverse, and update programmatically.

The knowledge base is live today at api.agent.ceo.

Why We Chose a Knowledge Graph

Most AI knowledge systems use vector databases. Embed your documents, store the vectors, retrieve by cosine similarity. This works for finding content that sounds similar. It fails when you need content that is actually connected.

When an agent asks "what changed since the last auth deployment?", vector search returns documents containing the words "auth" and "deployment." A graph traversal starts at the auth service node, follows edges to deployment records, then to configuration changes, then to any resulting incidents. The output is a connected subgraph of relevant context — not a ranked list of maybe-relevant documents.

We chose Neo4j as the foundation. The knowledge base stores pages (decisions, runbooks, analyses), entities (services, teams, technologies), and repositories (ingested codebases). Each page carries a vector embedding for semantic search, and typed relationships connect everything into a navigable graph.

Vector search finds the starting point. Graph traversal finds the context around it. Together, they give agents the kind of institutional knowledge that previously only existed in people's heads.

Multi-Tenant by Design

Knowledge bases in production hold sensitive data — security configurations, financial analyses, incident details. Flat access models don't cut it.

Every knowledge base is scoped to an organization. Within each org, content is organized into spaces with granular permissions. Individual pages can be public, org-internal, or restricted to specific roles. A security post-mortem stays with the security team. The resulting runbook update gets shared org-wide.

All access runs through the same Firebase JWT pipeline and MFA verification as every other Agent.ceo API call. No separate auth system, no special tokens.

MCP Integration: 19 Tools for Your Agents

The knowledge base isn't a web UI for humans to browse. It's an API surface for agents to use. We built 26 MCP (Model Context Protocol) tools that give agents full access:

• Search and retrieve — semantic search across pages, entity lookup, graph traversal
• Create and update — agents write new pages, update existing ones, manage relationships
• Ingest sources — pull in content from text, URLs, git repositories, or cloud storage (GCS/S3)
• Wikilinks — typed, directed relationships between pages create navigable knowledge graphs
• Freshness scoring — surface stale content before it misleads your agents

Claude Code connects directly to the knowledge base via MCP. Your agents query it, write to it, and build on each other's knowledge — all within their normal workflow.

Secure Access with PKCE OAuth

External tools connecting to the knowledge base authenticate via PKCE OAuth 2.0 — the same flow used by mobile and single-page applications where a client secret can't be stored safely. No API keys to rotate, no secrets in config files. The OAuth flow handles token issuance and refresh automatically.

This means Claude Code running on a developer's machine, an agent running in a Kubernetes pod, or a CI pipeline can all authenticate securely without sharing credentials.

What This Means in Practice

Here's what changes when your agents have persistent memory:

Onboarding accelerates. A new agent spun up on your org inherits the full knowledge graph — every past decision, every runbook, every architectural pattern your team has documented.

Context compounds. Each agent session adds to the knowledge base. An incident investigation becomes a page that future agents can reference. A deployment that required a workaround gets documented once, found forever.

Cross-agent knowledge sharing works. Your DevOps agent documents a Kubernetes configuration. Your security agent references it during an audit. Your CTO agent cites it in an architecture review. The knowledge graph connects their work without manual coordination.

Try It

The Agent-Native Knowledge Base is available now for all Agent.ceo organizations. Design partners can access the full API at api.agent.ceo.

If you're building AI agent systems and want persistent, structured memory that agents actually use — not just a vector store they sometimes query — we'd like to show you what we've built.

Reach out at agent.ceo to get started.

Related

• Build an AI Agent Knowledge Base with Wiki MCP Tools — hands-on tutorial
• Knowledge Graphs for AI Agents — the architecture behind organizational memory
• Graph Traversal vs Vector Search for AI Agents — why agents need both