A memory layer built for agents, not humans.

The problem isn't the agents anymore

Modern agentic workflows aren't one model doing one thing. They're a fleet.

Claude Code is great at writing software. Claude.ai is great for product thinking. You'll reach for other harnesses and other models for other specialties. Almost all of them speak MCP.

Which means the real bottleneck isn't the agents anymore. It's the memory they share — the place each of them reads from and writes to so the next one can pick up where the last one left off.

What we tried first

Obsidian is wonderful for humans, but it's a local, low-code app. Exposing it as a secure MCP to the outside world is not a trivial project. It was never built for that.

Notion is the other instinct, and it's a great product — for people. But it isn't pure markdown. It's blocks, mentions, comments, permissions, databases. All the affordances that make it powerful for human collaboration are friction for an agent that just wants to read and write text.

And the deeper problem showed up the moment we ran agents in parallel — even agents of the same kind. They'd all reach for the same memory file. They'd all edit it. They'd all clobber each other. Memory became a merge-conflict machine.

What we actually wanted

So we built it.

• Hosted, central, secure. A real MCP endpoint your agents reach over the network — not a desktop app pretending to be one.
• Vanilla markdown. No blocks. No proprietary schema. Just .md files in folders. What you write is what's on disk.
• Agent-native, not human-native. A small tool surface — search, read, update — designed for the way agents actually work, not retrofitted from a human collaboration tool.
• Idempotent edits via ETags. Every read returns an ETag. Every write asserts the one it expects. If another agent got there first, the write fails cleanly and the agent reconciles. No silent clobbers, no conflict guesswork.
• Conventions you can author. A scratchpad is what you get when there's no in-store way to tell an agent how to use the memory. Markbase ships _markbase.md as a per-folder governance file — what this subtree is for, what the frontmatter is, what's append-only. Agents read the chain root-to-leaf before they act and apply what they find. The opinion lives with the data, not in a CLAUDE.md you have to replicate into every harness.
• Typed records, when you want them. A folder of notes is fine until the same kind of record keeps recurring — decisions, RFCs, postmortems. Drop a _schema.md in the folder and you've defined the shape: agents append records that conform, and they can query the collection by field like a table. Still plain Markdown underneath.
• Knowledge that crosses projects. Each project's memory lives in its own workspace, but agents aren't confined to one. Ask an agent to design a feature in your new project using the architecture decisions from your old one, and it can read both in the same conversation. The work you've already done becomes input to the work you're about to do.

That's the whole product. A small set of tools, full version history under the hood, hosted by us so there's nothing to install or keep alive.

It's the memory layer we wanted the rest of our stack to have. Now it does.