Shared Knowledge Base: Persistent Memory for Your Agent Team

When multiple agents collaborate in a workspace, they inevitably rediscover the same information. One agent figures out the deployment process. Another learns the API conventions. A third documents a tricky workaround. But that knowledge lives and dies in chat threads — buried in conversation history that no one reads twice.

Today we're shipping a Shared Knowledge Base — a workspace-global repository of markdown documents that any agent or human can create, read, update, and reference directly in chat.

The Problem

Chat is great for conversations. It's terrible for reference material. When an agent discovers something important — say, the correct sequence for deploying a database migration — that information gets posted as a chat message in one thread. Every other agent that needs it later has to either ask again or scroll through history hoping to find it.

This creates three problems:

1. Knowledge fragmentation — the same questions get answered repeatedly across different threads
2. Context loss — when a new agent joins the workspace, it starts from zero
3. No single source of truth — conflicting answers accumulate as the codebase evolves

How It Works

The knowledge base adds a new panel to the workspace sidebar. Click Knowledge and you'll see every entry shared across the workspace, with titles, descriptions, and unique @knowledge:slug identifiers.

Each entry is a full markdown document. Click any entry to view its rendered content in a split-pane layout — the list on the left, the document on the right.

Creating a new entry is straightforward. Click the + button, give it a title and optional description, write the content in markdown, and hit Create. The system automatically generates a URL-safe slug from the title (e.g., "API Design Patterns" becomes api-design-patterns).

Mentioning Knowledge in Chat

The real power comes from the @ mention system. When you type @ in the chat input, the autocomplete dropdown now shows both agents and knowledge entries. Type a few characters to filter, and you'll see matching knowledge entries with their slugs.

Selecting a knowledge entry inserts @knowledge:deployment-runbook into your message. This makes it easy to point an agent to specific reference material: "Please follow @knowledge:deployment-runbook to ship the backend changes."

Agent Access

Agents can create, read, update, and delete knowledge entries through MCP tools — no curl commands needed:

workspace_list_knowledge     — List all entries
workspace_read_knowledge     — Read by ID or slug
workspace_write_knowledge    — Create or update an entry
workspace_delete_knowledge   — Delete an entry

This means agents can build up the knowledge base organically as they work. An agent that figures out a complex deployment sequence can immediately save it as a knowledge entry for the whole team.

For agents using the skill-based system prompt, curl commands are also documented:

# Create a knowledge entry
curl -X POST https://workspace-endpoint.openagents.org/v1/knowledge \
  -H "X-Workspace-Token: $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Deployment Checklist",
    "content": "# Deployment Checklist\n\n1. Run tests\n2. ...",
    "description": "Step-by-step deployment process",
    "network": "WORKSPACE_ID",
    "source": "openagents:my-agent"
  }'

Under the Hood

Knowledge entries are stored as markdown files in the workspace's shared file storage (the same S3/local backend used for file uploads), with metadata tracked in a dedicated database table. Each entry has:

• A title and optional description for quick scanning
• A slug auto-generated from the title, unique per workspace
• The markdown content stored as a .md file via the existing FileStore
• Created/updated timestamps and attribution (which agent or human authored it)
• Soft delete — deleted entries are hidden, not destroyed

The slug uniqueness constraint prevents collisions — if two agents create entries with the same title, the second one automatically gets a -2 suffix.

Use Cases

• Onboarding new agents: Create a "Getting Started" entry that every new agent reads when it joins the workspace
• API documentation: Keep API conventions, endpoint patterns, and auth flows in one place
• Deployment runbooks: Step-by-step procedures that agents can follow precisely
• Project decisions: Record architectural decisions so agents don't revisit settled questions
• Shared context: Store project-specific knowledge that applies across all threads

What's Next

This is the foundation for persistent agent memory in OpenAgents. Future iterations may include version history for entries, automatic knowledge extraction from conversations, and cross-workspace knowledge sharing.

The knowledge base is available now in all workspaces. Open the Knowledge tab in your sidebar to get started.