zetl — the team wiki your agents can actually use

The problem

Your AI tools make things up. You need answers you can check.

The AI in your wiki retrieves, paraphrases, and occasionally invents. You get plausible paragraphs with no trail back to what was actually written, by whom, or when.

What you have today

Notion + an AI button that fabricates when it doesn't know and cites nothing.

A RAG pipeline that retrieves chunks and lets the LLM reason freely — plausible answers, no auditable trail.

An Obsidian vault your team can't share and your agents can't see.

What zetl gives you

A shared Markdown vault. Your team edits it collaboratively. No new format, no lock-in.

Answers with receipts. Every claim cites the file and line it came from. Click through and read the source.

Contradiction detection. When two pages disagree, zetl tells you — before your agent guesses.

See it work

From a question to an answer you can check.

A session over a vault of product decisions. Ask a question, see the sources, find the contradiction.

Ask the vault

Standard wiki query — pages, backlinks, context.

Ask how do you know?

The answer with every source line cited.

Find contradictions

Pages that disagree — before an agent picks one at random.

zetl · acme-research

$ zetl links "release-candidate"

title:       Release Candidate
backlinks:   Cache · Scanner · Rust for CLI · ADR-003
outlinks:    good-cli-tool · docs-updated · type-safe

# A normal wiki answer. Fine — but your team still needs to know why.

$ zetl reason explain graph-complete --as table

Explanation for 'graph-complete':
  Conclusion: +D graph-complete

  Proof tree:
  graph-complete (definite) via r-graph-complete [strict]  [[release-readiness]]:13
    directed-graph (definite) via __fact_40 [fact]  [[Link Graph]]:17
    multi-hop-traversal (definite) via __fact_39 [fact]  [[Link Graph]]:18
    forward-links-done (definite) via __fact_9 [fact]  [[Graph Queries]]:10
    backlinks-done (definite) via __fact_11 [fact]  [[Graph Queries]]:11
    shortest-path-done (definite) via __fact_10 [fact]  [[Graph Queries]]:12

# Every claim traces to a file and a line.
# The proof tree IS the audit trail.

$ zetl reason conflicts

1 unresolved conflict(s) found:

1. Contested literal: cache-reasoning-results

   Rules for 'cache-reasoning-results':
     'r-cache-theory' [Defeasible]: mtime-based-cache ⇒ cache-reasoning-results  ([[Cache]]:29)
   Rules for '~cache-reasoning-results':
     'r-recompute-theory' [Defeasible]: incremental-rebuild ⇒ ~cache-reasoning-results  ([[Cache]]:34)

   No superiority relations between competing rules.

# The vault knows where it disagrees with itself.
# Before your agent picks one at random.

Why zetl

One idea, done properly.

The core

Answers with receipts.

Every answer cites the exact Markdown lines it was drawn from. When two pages disagree, zetl surfaces the conflict instead of quietly picking a side. You can show the chain to a stakeholder, an auditor, or your future self.

Every claim cites a file and a line
Contradiction detection across the vault
Same answer in the CLI, the browser, or an agent

And also

A plain-Markdown vault your team actually shares.

Real-time co-editing over plain Markdown under git. No new format, no proprietary store. Export is cp -r.

Real-time collaborative editing
Your vault is a git repo of Markdown files
Read it in Obsidian, Logseq, or plain vim

And also

Your agents, on an open protocol.

Claude, Cursor, internal bots — any MCP-compatible client can ask the same questions your team asks, and get the same cited answers back.

Open MCP endpoint, not a vendor lock-in
Scoped tokens when you need them
Audit log of every query

How it works

Local-first. Cloud-optional. Yours either way.

The zetl CLI is open source. Your vault lives in plain Markdown under git. The cloud is a sync, publish, and collaboration surface on top — never a lock-in.

┌───────────────────┐ ┌────────────────────┐ │ your laptop │ ◄─git─► │ zetl cloud │ │ ~/team-vault/ │ │ │ │ *.md │ │ published site │ │ .zetl/ │ │ collab room │ │ │ │ MCP endpoint │ │ zetl CLI │──token─►│ reasoning API │ │ build, serve, │ │ audit log │ │ view, reason, │ │ │ │ watch, mcp │ │ built on │ └───────────────────┘ │ Cloudflare │ │ Workers + DO │ └────────────────────┘

Your data, your disk

Every byte lives in your git repo in plain Markdown. The cloud is a mirror, never a database. Quit tomorrow and nothing breaks.

Same answer, everywhere

The same engine runs in the CLI, in the reader's browser, and on the edge. A question from a teammate and a question from an agent go through the same path.

Self-host at any time

Same binary, same Docker image. The cloud is optional infrastructure, never a captive dependency.

Features

Everything zetl does.

AGPL-3.0, source on Codeberg. Every feature available locally; the cloud is optional. Feature-gated capabilities (history, reasoning, MCP, semantic) compile in on demand.

Core

Graph & search

Obsidian-compatible wikilinks: [[target]], [[t|alias]], [[t#heading]], [[t^block]], ![[embed]]
Forward links, backlinks, multi-hop traversal, shortest path
Dead-link, orphan, and syntax diagnostics
Full-text content search with regex and frontmatter awareness
SimHash fuzzy page-name matching
BLAKE3 Merkle leaves for headings, paragraphs, code blocks, SPL
Two-tier incremental cache (mtime + hash) for index and theories

Reading

Viewing & rendering

Xanadu-style two-pane terminal reader with bridge connectors
Web UI with transclusions, backlinks, and inline editing
Static-site export: deployable HTML, same look, no server
Custom themes via Minijinja templates and static assets
Byte-deterministic RSS 2.0 / Atom 1.0 / JSON Feed 1.1
Scoped feeds, capability-cohort feeds, inbound subscriptions
SSRF-, XXE-, and decompression-bomb-safe ingestion

Reasoning

Defeasible logic

Vault-wide SPL theory: facts and rules extracted from Markdown
Conclusions with full provenance back to file + line
Proof trees explain why a conclusion holds
What-if analysis: add hypothetical facts, see what changes
Abductive reasoning: find facts needed to prove a goal
Conflict detection with resolution suggestions
Graph annotated with conclusions and vice versa

Time

Temporal queries

jj-backed silent snapshots, automatic on every index
Time-travel: --at "3 days ago", --at HEAD~1
Graph-evolution timeline across snapshots
Per-page history with link trends and change events
Auto-snapshot watcher (zetl watch) on FS events

Team

Collaboration

Passkey (WebAuthn) auth — Touch ID, security keys, no passwords
Roles: reader / editor / admin, per-page scoping via glob or SPL
Ed25519-signed invitation links, single-use, optional expiry
CRDT co-editing (Peritext) with git auto-commit on save
BIP39 recovery: one mnemonic derives account + server + SSH keys

Agents

Automation & extensibility

Lifecycle hooks: pre-build, post-index, on-save, on-agent, on-access
Render-pipeline hooks with typed AST and authoring CLI
Python and TypeScript helper libraries for hooks
First-class Pandoc, mdBook, and remark plugin adapters
MCP server: graph, search, reasoning as typed tools (stdio + HTTP)
User-signed JWT delegation, scoped per tool and per page
JSON output when piped, structured errors, --no-input for CI

Questions

Frequently asked questions.

How is this different from Notion + an AI button?

Notion's AI retrieves, paraphrases, and occasionally invents. zetl won't give you an answer it can't trace back to specific Markdown lines in your vault — and it tells you when two pages contradict each other, which no LLM can do reliably.

How is this different from a RAG pipeline over our wiki?

RAG retrieves chunks and lets the LLM reason freely. You get plausible paragraphs with no audit trail. zetl reasons symbolically over what your Markdown actually says: the answer is a chain of citations, not a paragraph, so you can click through and check every step.

Under the hood — what's actually doing the reasoning?

A defeasible logic engine (spindle) that handles rules with exceptions and conflict resolution with a formal semantics. You don't need to know that to use zetl — but if you want to write rules directly, the syntax is S-expressions (SPL) and it's all documented.

Do we have to write "rules" for every document?

No. Wikilinks and plain Markdown work out of the box — you get the team wiki, collab, MCP search, and history with zero effort. The reasoning layer activates when you add SPL code blocks to pages where you want defensible conclusions. Most teams add them gradually, starting with ADRs, decision logs, and policy documents.

Is the CLI really open source?

Yes. AGPL-3.0, on Codeberg. Everything core to the product — wikilinks, search, reasoning, history, collab server, MCP server — runs locally from the open-source binary. The cloud is a hosted version of the same binary plus a control plane for provisioning, billing, and audit. You can self-host at any time.

What happens to my data if you go out of business?

Your vault is a git repo of Markdown files on your own disk. Our cloud is a mirror, not a database. You lose hosted collab and hosted MCP — you keep everything else, including the reasoning engine, by running the open-source CLI.

Does it work with Obsidian / Logseq / Foam vaults?

Yes. zetl reads any Markdown vault that uses [[wikilink]] syntax. It never modifies your files — the index and reasoning cache live in a .zetl/ folder you can gitignore. Use Obsidian for editing, zetl for team hosting and agents.

A wiki whose answers show their work.