The knowledge problem nobody talks about
Your team has runbooks, research, policies, and vertical expertise—but it lives in scattered docs, wikis, and Slack threads. When you bolt on a generic RAG chatbot:
Chunks lose structure
Flat embeddings miss hierarchy, deferrals, and canonical sources. Agents hallucinate or cite the wrong doc.
No access model
Everything leaks into one index—no way to say who, human or agent, may see what. Sensitive SOPs sit right next to public docs.
Metadata is an afterthought
Without retrieval_hint and defers_to, agents cannot route subtopics or skip out-of-scope content. Support and agent runs fail silently.
Result: expensive RAG that still feels dumb
You paid for embeddings and a chat bubble—but agents still query the open web or wrong chunks.
What TPS Report does instead
✓ Routed via metadata…
- ✓ canonical_for: pricing-playbook
- ✓ defers_to: implementation-guide for setup questions
- ✓ retrieval_hint: negative match on deprecated 2023 PDF
- ✓ Grounded answer from published report collection
Why TPS Report is different
Generic RAG / wiki dump
- Upload files → embed chunks
- Everything leaks into one index
- Agents search blind
- Structure lost at index time
TPS Report
- Codify with agent-oriented metadata
- RBAC on every report, section & page
- Agents obey the same access rules as readers
- Hybrid graph + vector retrieval
- Execute on your corpus—and remember what they learn
The key insight
One codified structure, two consumers: humans browse it, agents execute on it—and the same taxonomy, Retrieval Contract, and access rules govern both. Obsidian is optional authoring, not the product.
We stand out on the combination — not a single feature checkbox
Our research mapped ~30 products across markdown publish, doc SaaS, and AI brain territory. Zero cover all five pillars TPS Report is built on.
Publish tools stop at static HTML. RAG APIs start at file upload. Doc SaaS optimizes for team wikis. TPS Report owns the missing middle: one codified structure with an agent-ready metadata contract and access control that readers and agents both obey.
Publish territory
Obsidian Publish, Quartz, Foliate, GitBook
Get content online — no agent-ready structure, no access model
AI brain territory
Glean, Ragie, Zep, Mem0
Retrieve or remember — no codified structure or per-page access control
TPS Report
Codified structure for reader + agent
Owns codify → structure → access-control → retrieve → remember
The five pillars — what we measure against everyone else
Reasoning-grade retrieval
Hybrid graph + vector: multi-hop traversal, centrality scoring, and prerequisite chains — not naive chunk search.
The Retrieval Contract
Every doc declares what it's for — and what it's not for. A versioned metadata contract enforced at authoring and at sync, so agents never misfire.
Reachable everywhere — plugins & MCP
Browser-native, an Obsidian sync plugin for vault-native authors, and a native MCP server that exposes your corpus as tools to any MCP agent — Claude, Cursor, whatever ships next.
Bidirectional editing (cloud + local)
Edit online or in Obsidian; sync keeps local vault and cloud corpus aligned both ways.
Access control — RBAC for humans & agents
Role-based access on every report, section, and page — and agent retrieval obeys the same rules as readers. Monetization is optional on top: the same RBAC powers a membership portal when you want one.
| Dimension | TPS Report | Typical alternatives |
|---|---|---|
| Reasoning-grade retrieval | Agents follow real relationships between documents, not embedding proximity. | Flat embedding search (RAG APIs) or no retrieval at all (publish tools) — nearest-chunk matching with no relationship awareness. |
| The Retrieval Contract | Agents know what a document is for — and what it isn't — so they don't over-retrieve or misfire. | Basic YAML tags or none. |
| Reachable everywhere — plugins & MCP | Author where you already work; let any agent — ours or not — reach the same substrate. | Obsidian-native only with no agent layer, cloud-only with no vault path, or RAG APIs with no plugin/MCP surface at all. |
| Bidirectional editing (cloud + local) | No fork between "where you write" and "what you publish and index." | One-way vault → static site, or cloud-only with no local editor. |
| Access control — RBAC for humans & agents | One access model governs readers and agents alike — govern first, monetize if desired. | Public static sites, basic password gates, or RAG indexes that leak everything to every query — access control is bolted on, and agents bypass it. |
Where we do not try to win head-to-head
- Not a free SSG — Quartz wins on cost for public-only gardens
- Not enterprise app search — Glean wins at indexing Slack, Jira, and 100+ connectors
- Not dev-docs polish — Mintlify wins for API reference sites
- We win when you ship structured, access-controlled, agent-ready knowledge bases with agent chat on your corpus
Our strength: consultants, Obsidian teams, and subject-matter experts shipping structured, access-controlled, agent-ready knowledge bases (paid or not) — not free blogs or enterprise app search. See full competitor research →
Who it is for
Consultants & KnowOps teams
"We ship client KBs with scoped collections and metadata contracts. Agents finally stop citing the wrong playbook."
Vertical knowledge products
"RBAC lets us open public excerpts and lock the full library—one access model, same corpus for browsing, agent chat, and (when we want) paid membership."
Obsidian-native teams
"Author in the vault, sync when ready. Gatekeeper validates metadata before anything goes live."
Time to grounded agents
Structured publish + metadata beats rebuild-the-index every time someone asks a nuanced question.
Manual wiki + bolt-on RAG
Every new doc type needs custom prompt hacks.
TPS Report workflow
Optional Obsidian sync when vault authoring fits.
One knowledge base. Reader and agent.
Structured for both audiences—see How it works for the four-step workflow.
Loading FAQs...
The choice
Keep dumping files
Hope embeddings and prompts compensate for missing structure. Re-index when agents misfire.
Codify with TPS Report
Structure knowledge with metadata and RBAC, then run agents on a corpus you control—routing that respects your graph and your access rules.