TPS Report sits at the intersection of two territories: markdown-to-static publish tools and AI brain / Graph RAG platforms. Most products do one. We give both audiences one codified structure — humans browse it, agents execute on it — with RBAC on every page that readers and agent retrieval both obey. Monetize with it if you want.
Loading platform features...
What we measure TPS Report against — and what most competitors in our territory cannot combine.
Five dimensions that matter for a knowledge + memory substrate: reasoning-grade retrieval, the Retrieval Contract, reach (plugins & MCP), bidirectional editing, and RBAC for humans & agents. Most territory products cover one or two — not all five.
| Dimension | TPS Report | Typical publish / doc / RAG tools | Advantage | ||
|---|---|---|---|---|---|
| Reasoning-grade retrieval | Hybrid graph + vector retrieval — multi-hop traversal, PageRank-style centrality, and prerequisite chains ("read this first") on your codified corpus. | Flat embedding search (RAG APIs) or no retrieval at all (publish tools) — nearest-chunk matching with no relationship awareness. | Agents follow real relationships between documents, not embedding proximity. | ||
| The Retrieval Contract | Every document carries a versioned metadata contract — hyde_questions, retrieval_hint, defers_to, canonical_for, and a mandatory "do not use for…" clause — enforced at authoring and at sync. | Basic YAML tags or none. Frontmatter is cosmetic, not an agent routing or canonical-source contract. | Agents know what a document is for — and what it isn't — so they don't over-retrieve or misfire. | ||
| Reachable everywhere — plugins & MCP | Author online or in Obsidian via a bidirectional sync plugin. A native MCP server exposes your corpus as tools to any MCP-compatible agent — not captive to one runtime. | Obsidian-native only with no agent layer, cloud-only with no vault path, or RAG APIs with no plugin/MCP surface at all. | Author where you already work; let any agent — ours or not — reach the same substrate. | ||
| Bidirectional editing (cloud + local) | Edit in the online editor or Obsidian; sync flows both ways so cloud and local stay the same source of truth before publish. | One-way vault → static site, or cloud-only with no local editor. Edits in one place do not round-trip. | No fork between "where you write" and "what you publish and index." | ||
| Access control — RBAC for humans & agents | Role-based access on every report, section, and page — and agent retrieval enforces the same rules as readers. Monetize on top when you want: the same RBAC powers public teasers, member unlocks, and a signup funnel. | Public static sites, basic password gates, or RAG indexes that leak everything to every query — access control is bolted on, and agents bypass it. | One access model governs readers and agents alike — govern first, monetize if desired. |
Competitors mapped against the five dimensions above — most cover one or two, not all five.
Digital gardens, vault-native publish, self-hosted static generators
Hosted SaaS ($8/mo+) — select vault folders, graph view, wikilinks
Strength: Lowest friction for Obsidian users; native graph + publish UX
Gap vs TPS: No gated KB product layer, no agent-oriented metadata contract, no agent execution brain
Open-source SSG — Obsidian-flavored MD, graph, backlinks, Git deploy
Strength: Free, battle-tested digital garden; upstream-safe customization
Gap vs TPS: Static site only — you build/host; no publish workflow, access control, or RAG layer
Vault-native SSG — config in `.foliate/`, public vs published tiers
Strength: Flexible Publish alternative; stays inside vault; incremental builds
Gap vs TPS: Static output only; no online authoring, monetization, or agent retrieval
Go binary SSG — Obsidian parity (canvas, callouts, wikilinks)
Strength: Single binary, fast builds, deploy anywhere
Gap vs TPS: Site generator, not a KB publishing + AI brain platform
Obsidian plugin + hosted publish — CSS/JSON theming
Strength: Cheaper than Publish; granular site control from vault
Gap vs TPS: Publish-focused; no structured agent metadata or execution substrate
Next.js + shadcn Obsidian publish stack (Quartz-inspired)
Strength: React ecosystem customization for digital gardens
Gap vs TPS: Developer SSG; not end-to-end KB + agent product
General SSG + markdown/Git — plugins for wikilinks
Strength: Maximum control, zero vendor lock-in, great performance
Gap vs TPS: Engineering-heavy; no built-in KB gating, metadata contract, or agent chat
Team docs, developer portals, wikis with optional AI Q&A
Git + visual editor SaaS — spaces, AI search/Q&A, collaboration
Strength: Cross-functional docs; AI-assisted answers on published docs
Gap vs TPS: Docs portal, not codified graph metadata for agent routing; weak on Obsidian/vault path
Developer-docs SaaS — MDX, OpenAPI, AI assistant, MCP/llms.txt
Strength: Fast API docs, AI-native dev experience
Gap vs TPS: Dev-docs niche; not vertical KB products or agent-oriented metadata routing
Workspace wiki — Q&A over pages, collaboration
Strength: Familiar editor; broad team adoption
Gap vs TPS: Flat page model; not publish-first KB with Graph RAG metadata contract
Enterprise wiki — Rovo/AI search across Atlassian stack
Strength: Enterprise permissions, Jira integration
Gap vs TPS: Internal wiki; not customer-facing gated KB + agent execution product
API reference & developer hub platforms
Strength: Interactive API docs, try-it playgrounds
Gap vs TPS: API docs vertical; not general codified knowledge for agents
Open-source docs frameworks (Meta/Astro)
Strength: Self-hosted, customizable doc sites
Gap vs TPS: Static docs codebases; no managed publish + agent brain layer
Team wiki — self-host or cloud, markdown-friendly
Strength: Clean wiki UX, reasonable self-host story
Gap vs TPS: Collaboration wiki; not metadata-rich agent retrieval platform
Team knowledge bases with AI search
Strength: Internal enablement, browser extensions, quick capture
Gap vs TPS: Internal KB tools; not publish + Graph RAG for external/agent products
Context engines, enterprise search, temporal KG memory — ingest & retrieve
Enterprise Work AI — unified index, Enterprise Graph, agents, 100+ connectors
Strength: Permission-aware search at scale; org + personal graphs
Gap vs TPS: Indexes existing SaaS sprawl — you don’t publish structured KB products inside it
Multiplayer agent workspace — shared agents, company context
Strength: Team agent building and governance
Gap vs TPS: Agent orchestration layer; not author-publish-index your own codified corpus
Context engine API — vector + keyword + summary indexes, MCP, entity extraction
Strength: Production RAG pipeline as a service; multi-tenant isolation
Gap vs TPS: Ingestion/retrieval infra — you bring unstructured docs; no publish workflow or metadata contract
Temporal knowledge graph / Context Lake — bi-temporal facts, hybrid retrieval
Strength: Graph-first agent memory; invalidates stale facts over time
Gap vs TPS: Memory API — not a human-facing KB publish + gating product
Memory layer for agents — extraction pipeline, optional graph (Mem0g)
Strength: Drop-in personalization; LangChain/LlamaIndex integrations
Gap vs TPS: Conversation memory — not structured report authoring + canonical routing
Managed RAG — chunk, embed, retrieve, rerank
Strength: Fast path to “chat with PDFs”
Gap vs TPS: File dump RAG; no defers_to, canonical_for, or publish layer
Open-source enterprise search + chat over connectors
Strength: Self-hostable Glean-like experience
Gap vs TPS: Connector search — not codified KB authoring + productized reports
DIY graph + vector stacks
Strength: Full control for engineering teams
Gap vs TPS: Build-it-yourself; TPS Report productizes publish + metadata + retrieval
Upload files → assistant with retrieval
Strength: Quick prototypes
Gap vs TPS: No graph metadata, gating, or KB-as-product workflow
Worth knowing — touch publish OR retrieval, rarely both
Structured content APIs → frontends
Strength: Content modeling for apps and marketing sites
Gap vs TPS: CMS for apps — not agent-oriented Graph RAG metadata or chat on corpus
Support bots trained on help center articles
Strength: Customer support automation
Gap vs TPS: Support vertical; articles are help docs, not agent routing graphs
Upload knowledge → branded chatbot
Strength: Fast internal bots
Gap vs TPS: Closed garden; no publish, monetize, or metadata contract across reports
Codify your expertise, gate access, and let agents retrieve the right context — not just the nearest chunk.