The runner is a commodity. The governance is not: one shared memory, an independent-family reviewer, and a ledger you own.
Every governed-loop run lands as one row. The row carries the maker's output, the reviewer's verdict on each question, what it cost, and the hash of the row before it. Nothing edits in place: to rewrite one row you would have to rewrite every row after it, and the hashes would tell on you.
The Chain is proof of what a machine did on your behalf, in order, with receipts. It does not care whose model is best this quarter. Export it whenever you want; it is yours, not a log you rent.
When someone asks what the agent did and who approved it, the answer is one view, not a flushed context window.
End a session, run an agent step, file a note over MCP: the same loop runs before anything touches your memory.
A maker model does the work: writes the synthesis, edits the files, drafts the reply. DeepSeek, on Nebius, reading your corpus.
A model from a different family answers a fixed set of yes/no questions about the work. One verdict per question, no vibe-check. You pick the family; the only rule is it cannot be the maker's.
What passes is filed to Memory and appended to the Chain. Each row carries the verdicts, the cost, and the hash of the row before it.
Even the vendors admit the gap. Their own guides prescribe verifier agents and audited progress claims, then ship no ledger you own and no reviewer from outside their own family. Their verifier is another instance of themselves. The two omissions are this product.
The roster makes "different family" possible. Qwen, Kimi, DeepSeek, GLM: open-weight families on Nebius (EU). No proprietary frontier in the default. Bring your Claude or GPT key and they join the roster. Diversity is load-bearing, not branding.
You approve what files. The loop checks and shows; it does not decide. And half the gate is not a model at all: path allowlists, spend caps, and irreversible-action stops are plain code. Rules are rules, not another opinion.
Memory is your notes, your patterns, and every session you have closed: Journal, IDE, research. Each carries a version and an attestation. The next session reads from it, so it has to be right. Nothing gets in by accident.
Promotion takes one of two things: your tap, or a passing cross-family review. A thought can be brilliant and still wait outside until it earns the spot. That friction is the feature. A memory you can trust is worth more than one that is merely large.
Your work travels in lanes. Founder, advisor, board: three hats, three corpora, three audits, kept separate by construction. Patterns travel separately too; the open patterns-starter repo is yours to fork, in plain Markdown, in your own repo.
Models change. Your history does not.
Surface is the current-state snapshot. Your inbox right now. What got auto-fetched this morning. The working desk, not the archive: it changes all day and that is fine, because none of it counts yet.
Surface never promotes to Memory on its own. An item sits here until you save it, and then it crosses over with a version and an attestation, like everything else. The line between what is happening and what you have decided to keep stays bright.
Gmail and Calendar connect to Spegling, not to each AI you happen to use this month.
Tokens live in Spegling's encrypted vault. The calling AI never sees them and cannot leak what it never had. Revoke once, revoked for every client.
The tools are commodities. The boundary is the product.
Read the inbox, draft a reply, check today's calendar: the agent calls a governed capability. The gate is the only door, whichever client is asking.
Three Gmail accounts, three hats, three ceilings. The founder hat cannot read the board hat's mail. The scope follows who you are being right now.
And this is why people use it without being told to. Nobody adopts a governance tool because policy says so. People come because the useful things live behind the gate: mail, calendar, corpus, search. One endpoint, from whatever client they already like, or in sessions inside Spegling itself. A week in, the side effects turn out to be the point: the same context follows you into every session you start, and a reviewable history assembles itself while you just get things done. The convenience is the adoption plan.
The model is not the moat. Everyone has a model, and a better one ships every few weeks. Three things here are hard to copy: the model that has read all of you, the gate your tools already live behind, and a ledger that can prove what happened.
The maker and the reviewer come from different model families. A maker grading its own homework is not a check; a different family means the second opinion is not the same blind spot twice.
You hold the key. Walk away, and the data walks with you.
No scores, no summary judgment. Because every check is a yes or a no, a failed review tells you exactly what failed. Vague approval is impossible, and so is vague blame.
Forging one decision means forging every row after it, and the hashes still would not line up. The proof does not depend on trusting Spegling: the exported chain checks itself.
Spegling is a surface and a substrate. Pick either; the loop runs the same way underneath.
Point your AI client at Spegling's MCP server. Your notes, patterns, news, wiki, and tools appear inside Claude Desktop, your IDE agent, or your own code. Setup guide.
{
"mcpServers": {
"spegling": {
"url": "https://api.spegl.ing/mcp/t/<tenant>",
"headers": {
"Authorization": "Bearer sk_…"
}
}
}
}
Sign in. The Journal opens. Pour for three minutes; the partner pushes back from your own patterns. File what you keep.
Either way, every call lands as one row on the Chain, and the same memory serves both doors. A session started in Claude Desktop at noon and one in the studio that evening read the same corpus, and tomorrow reads both.
One goal, one session, one transcript. The partner pushes back the same day. Nothing to set up first.
Surface starts filling on its own, and from now on every AI you use reaches mail through the gate, never holding the keys.
You end a session, the cross-family review runs, and the proposals you approve cross into Memory with a version.
The session opens already knowing what you decided. You stop re-explaining yourself to a blank box.
A week of runs, each with its verdicts and hash, exportable whenever you want. Nothing is locked behind the door you came in through.
The MCP endpoint takes ten minutes and a config block. The studio takes a sign-in. Both land on the same ledger. Access is by invitation while the pilots run: write a line about what you would run through it, and a person answers.