Basalt governs.
The trust layer for AI-generated work. Your agents push markdown over MCP and get back branded, permissioned, versioned pages — then read your review feedback back, so the round-trip actually closes. The source never leaves git.
$push markdown → get a governed URL back▍Built for the agents already in your stack
Cofoundy runs its own operating memory on Basalt — customer zero, in production.
Proof, not promises
tools in one MCP
read · write · review · republish
versions retained
every publish is immutable
git-native
zero lock-in, leave anytime
MCP operates the company
agent-as-real-user auth
The gap
Agents generate enormous amounts of good work — specs, decisions, reports — and all of it dies in a git repo, invisible to anyone who won't cat a file. No branding, no access control, no version history a human can trust, no way to review what the machine wrote before it becomes truth.
So you copy it to Notion, export a PDF, paste a link. That manual labor quietly cancels out the speed AI was supposed to buy.
# Q3 Strategy
The plan the agent wrote. Sharp, sourced, decided.
## Pricing · ## Risks · ## Roadmap
— and nobody who matters will ever cat it.
Markdown in. Branded truth out.
This is what your agent's markdown becomes.
A branded, permissioned, versioned page — with the agent's proposed edit waiting for a human to accept. Same markdown, still in git.
Acme · Strategy
Q3 Strategy
Where we win this quarter
The strongest signal from H1 is that mid-market teams adopt fastest when onboarding is collapsed to a single integration step. Q3 concentrates engineering on that wedge and defers the broader enterprise surface until the motion is proven.
Activation rate
68%
▲ 12 pts vs H1 · illustrative
Decision
Ship the single-step integration to all mid-market accounts before pursuing net-new enterprise logos. Revisit at the Q3 midpoint review.
This page is the source of record for the decision above. Edits proposed by an agent appear below for review — nothing changes until a human accepts.
Can view · 4
Version history
Markdown in. Trusted truth out.
Four moves between a prompt and durable truth
Agents create
Your agent pushes markdown over MCP as a real authenticated user — inheriting the grants of the human it represents. Push a doc, get a URL back.
Basalt governs
Access resolved per-document. Branded MDX rendered server-side. Every version immutable and retrievable. The control plane between creation and trust.
Humans decide
Async review where one collaborator is an agent: it proposes a diff, you accept or reject, it reads your feedback back over MCP and republishes. No CRDT, no polling.
Companies remember
Versioned, auditable, retrievable. Work worth making is work worth keeping — durable organizational memory, not a chat that scrolls away.
The collaboration loop
The multiplayer tool where one of the players is an agent.
Most "AI integrations" are read-only afterthoughts — the round-trip breaks, and the agent never sees what a human rejected or why. Basalt closes it: the agent authenticates as a real user, proposes a diff, and reads its feedback back over MCP.
No CRDT cursors. No polling. No webhook. The human re-triggers the agent — and the work converges into something a company can stand on.
“Notion's MCP is SO bad.”
Agent proposes
mcp: publish_doc("q3-strategy.md")
a reviewable diff
Human reviews
annotate → "tighten the pricing section"
accept / reject, anchored to location
Agent reads feedback
mcp: get_review_feedback()
sees the exact annotations
Agent republishes
mcp: update_doc(...)
the round-trip closes
Not an editor — a governance substrate
The moat is the substrate, not the cursor.
The clones are racing to build the editor. Basalt deliberately won't. The durable advantage is whether the work can be trusted.
Agent-as-real-user MCP
The agent isn't a feature bolted on — it logs in as a real authenticated user and inherits that human's grants. Identity from the IdP, authority from your grants. It proposes a diff, you accept or reject, it reads the verdict back and republishes. The round-trip actually closes.
Multitenant RBAC
Access resolved per-document against grants — public, tenant, team, user, org. Most-specific path wins. A doc you can’t read is indistinguishable from one that doesn’t exist.
Immutable versions
Every publish is pinned and retrievable — closer to Vercel than Notion. Diff across history, restore any version.
Branded MDX
Markdown in, branded pages out. StatCards, matrices, charts — server-side, no hand-styled HTML.
Async review loop
Per-doc review toggle: some docs are governed, some publish direct. Annotate, accept, reject — the agent reads the verdict and tries again.
Zero lock-in
Content stays as markdown in git the entire time. You can leave with everything you brought — which is exactly why teams trust it.
The whitespace no one fills
Agent-native and governed.
Human-first tools have governance but treat the agent as an afterthought. Agent-first substrates are native but ungoverned. Basalt is the only corner that's both.
| Capability | Basalt | Notion | Obsidian | GitBook |
|---|---|---|---|---|
| Markdown stays in git | ✓ | — | ✓ | ✓ |
| Multitenant governance / RBAC | ✓ | ✓ | — | ✓ |
| Agent as a first-class author | ✓ | — | — | — |
| Working agent round-trip (MCP) | ✓ | — | — | — |
| Immutable versioned artifacts | ✓ | — | — | ✓ |
| Review loop where one player is an agent | ✓ | — | — | — |
| Zero lock-in | ✓ | — | ✓ | — |
Questions
Frequently asked
What is Basalt?
Basalt is the trust layer for AI-generated work. Agents push markdown over MCP and Basalt returns branded, permissioned, versioned, and reviewable pages — durable organizational truth, without the content ever leaving git. The shorthand: agents create, Basalt governs, humans decide, companies remember.
How is Basalt different from Notion, Obsidian, or GitBook?
Human-first tools like Notion and GitBook have governance but treat the AI agent as a bolted-on afterthought; agent-first tools are native but ungoverned. Basalt is the only one that is both agent-native and governed: the agent is a first-class author with a working MCP round-trip, access is resolved per-document with multitenant RBAC, and your content stays as markdown in git the whole time — so there is zero lock-in.
What does “agent-as-real-user” mean?
The agent is not a special integration. It logs in over MCP as a real authenticated user and inherits the grants of the human it represents — identity from the IdP, authority from your grants. It proposes a diff, a human accepts or rejects, and the agent reads that verdict back over MCP and republishes. The collaboration round-trip actually closes.
Does my content get locked into Basalt?
No. Your content stays as markdown in git the entire time; the branded page is rendered server-side from that source. You can leave with everything you brought — which is exactly why teams trust it.
How does the review loop work?
It is async review where one of the collaborators is an agent. The agent proposes a change as a reviewable diff; a human annotates, accepts, or rejects from a branded page; the agent reads the verdict back over MCP and republishes, with the version pinned and grant-checked. No CRDT cursors, no polling, no webhooks.
Which agents and tools does Basalt work with?
Any MCP client — Claude Code, Cursor, Codex, and others. One MCP exposes the full surface: read, write, review, and republish. Basalt is built for the agents already in your stack.
How much does Basalt cost?
There is a free tier, a Pro tier around
Give your agent a place where its work becomes truth.
Connect over MCP, push your first doc, and get a branded, permissioned, versioned URL back — in about two minutes. No CMS to stand up, no format to migrate into.
Free tier · ~
Your content stays markdown in git — leave anytime, take everything.