Open source · Agent-native
Docs your team and your agents write together.
Connect an agent and tell it to write down what it knows — or bring the markdown you already have. Your team edits in the browser, every agent reads the current version, and nothing lands without a person approving it.
Works with Claude Code, Codex, and whatever agent your team already uses — open source, no per-seat.
Every read provable — see what each agent read, and when.
When your team updates a doc, your agent should know.
- Provable version history
- No lost edits
- Secure, scoped access
- Portable, no lock-in
See it on day one.
These prompts are real — copy one, paste it into the agent you already have open, and watch what comes back.
Un-strand your rules files
>Read CLAUDE.md and AGENTS.md, and file each section into Corpus as its own document.
It drafts each section as a proposal; you approve. Your conventions stop living in eight repos that quietly disagree — and the next repo, the next agent, and the next teammate all start from the same set.
Get it out of the context window
>Walk the payments module and write down how refunds actually work today. File it to Corpus.
The agent already worked this out to do the job. Approve it once and the knowledge outlives the session — where your team can read it, and fix the part it got wrong.
One fix, every agent
>If a Corpus document contradicts what you find in the code, file a correction with suggest_edit rather than working around it.
The next agent that trips over a stale runbook proposes the fix instead of quietly routing around it. Whoever owns the doc approves in a click, and every other agent has it on its next run.
Never act on a stale doc
>Re-read the Corpus guidance between major tasks — the team edits these docs while you work.
Your support lead fixes the refund window at 9:00. The bot quotes the new one at 9:05. No re-index, no reconnect, no engineer in the loop.
From scattered to canonical.
Four moves from markdown spread across repos, Notion, and people's heads to the one source your whole team and every agent works from.
- 01
Get it written down
Import the markdown you already have, write it in the browser, or point an agent at an empty corpus and tell it to draft what it knows. All three land as versioned documents.
- 02
Decide what each agent sees
Group the documents an agent is allowed to read. Sales gets the sales docs; the coding agent gets the conventions. Its credential reaches that set and nothing else.
- 03
Agree on what's true
Comment on a passage, propose an edit, accept it hunk by hunk. Agents file proposals the same way — nothing becomes canonical until a person approves it.
- 04
Everything runs on it
Every agent reads the approved version on its next run. Edit once and all of them are current — no re-paste, no reconnect, no drift.
More than storage. A source of truth agents can trust.
Every capability answers one question: is this the right context, and can you prove it?
Provable history
Every version is kept and stamped. Prove exactly which version an agent read and when, and spot a changed doc at a glance. Nothing is ever silently overwritten.
Edit together, safely
Comment on any passage, propose edits as suggestions, then accept them hunk by hunk — the whole review loop, in the browser. Two people can edit at once and nothing is silently overwritten.
Agents propose, people approve
An agent can draft a new document or file an edit from what it just learned doing the work. It arrives as a suggestion you accept hunk by hunk — never an auto-applied write.
Scoped agent access
Each agent connects through its own binding to exactly one set of documents. It reads that set and nothing else — not the rest of the project, not another team's docs.
Portable, no lock-in
Export everything as one portable bundle: documents, groupings, and full history. It is also how you move into Nicia when you're ready to run agents on it.
Yours to run
The whole multi-tenant product is open source. Run it single- or multi-tenant on your own infrastructure. Nothing gated, no license key.
Free forever. We never charge per seat.
Bring your whole team and every outside collaborator. Knowledge stays siloed because adding people costs money, so we made that impossible to charge for. The hosted version is free, not a trial.
Need SSO, SCIM, audit export, data residency, or an SLA? Talk to us →
Run your whole team's agents on one Corpus. That's Nicia.
Take your Corpus straight in. Your team's agents run on it together, true multiplayer: shared runs, evals, and policy gates. Knowledge and compute in one place, plus sync from Google Drive, Notion & more.
Free
- Fully managed, nothing to run or maintain
- Unlimited projects, documents, and agent connections
- 10 GB of markdown per project (millions of documents)
- Every version kept, permanently
- Full MCP access, OAuth & scoped API keys
- Portable bundle export: your data, no lock-in
Why not Notion, Google Docs, or a Git repo?
Because none of them were built to hand an agent the right version — or to let it hand something back.
- A Notion page or shared doc isn't built for an agent to read — let alone write back to.
- Agents read the approved version over MCP and file proposals back through the same door. Always the current version, never a page they mis-scrape or never see updated.
- Paste it into a repo, a folder, or each tool and the copies drift.
- One canonical version; every agent reads the current one live. No copies to chase.
- Docs rot because the person who knows won't open a pull request to fix three words.
- Whoever knows writes it — in a browser, or as an agent's proposal after it hits the gap. Whoever owns it approves in a click.
- No one can say which version an agent actually used.
- Full saved history. See and prove exactly what each agent read, and when.
Built on solid foundations.
The unglamorous infrastructure decisions that keep your context correct, provable, and yours, no matter how big the team or how many agents read it.
- Still just markdown — structured underneath
- You write plain markdown. Nothing to model, no graph to learn. Underneath, Corpus tracks how documents and the sets they belong to relate (a graph, via TypeGraph) so one document feeds many sets without copies. Change it once; every agent is current.
- Content-addressed versions
- Every version is fingerprinted by its exact content. Change one character and Corpus knows, so you can prove precisely which version an agent read, and catch a silent edit instantly.
- An append-only history
- Nothing is ever overwritten or deleted. Every edit is a new link in an unbroken chain. Revert anything, audit everything, lose nothing.
- MCP-native, scoped per connection
- Agents connect over the open Model Context Protocol through a named binding to exactly one set of documents. Any agent in seconds; each only ever sees what that binding grants, and the only thing it can write back is a proposal.
- A CLI and REST API, beyond MCP
- MCP is how agents read and propose. For people and automation there's a REST API and a Git-free CLI —
corpus list / pull / push— to sync markdown from your terminal or CI, pluscorpus mcp addto wire up Claude Code, Cursor, or VS Code in one command. A version check refuses a stale overwrite, so automation never clobbers a newer edit. - Isolated per project, at the edge
- Each project is its own isolated store running on Cloudflare's edge. Fast wherever your team is, with no servers to run or scale.
- Don't trust us. Read the code.
- A modern, Apache-2.0 codebase you can audit line by line, run yourself, and export from anytime. Every claim on this page is verifiable. No black box, no lock-in.
Self-host it in minutes.
The whole product is open source. The complete multi-tenant store, nothing gated. No license key, noee/ directory. Single-tenant or multi-tenant is your call; no feature is withheld.
$ git clone https://github.com/nicia-ai/corpus$ cd corpus && pnpm install# create the schema (run this first)$ pnpm db:migrate# serve it — app.<your-domain> on Cloudflare$ pnpm devWhen you're ready to run agents on it
Run your whole team's agents on your Corpus — that's Nicia. One bundle, zero rewrite.
- Speed
- Each step runs on the right-sized model. Agents finish in seconds, not minutes.
- Humans
- Approval gates route to named people. Nothing ships until someone signs off.
- Files
- Every run's inputs and outputs, versioned and diffable. Always know what an agent used and made.
- Learning
- Every run is graded; approved improvements compound. The operation gets sharper over time.