Agent-native team wiki · documents itself · in Claude & ChatGPT
Point tela at your sources — a git repo, a Jira project — and Atlas writes a cited, coverage-checked wiki, then keeps it fresh as they change. Your agents search that wiki by meaning and read, write, and cite it from inside Claude and ChatGPT. Real-time editing for the humans; SSO, scoped access, and an audit trail for the team.
Free to start · your markdown, exportable anytime · self-host if you'd rather
When a service degrades, the on-call engineer owns the timeline until handoff. Keep this page open during an incident.
tela incident open "api-latency" --sev 2
Atlas · documents itself
Atlas writes them. Point Atlas at a source — a git repo or a Jira project — and it reads the source, plans a wiki structure, drafts cited markdown pages, and publishes them into a space as ordinary tela pages. Then it watches the source and regenerates when it moves ahead. The pages are real tela pages — searchable, shareable, revisioned — the same wiki your agents reason over.
github.com/acme/deploy-svc
behind upstream → regenerated 2h ago
Deploy surface
The deployd service exposes the rollout API and reads its
tunables from the environment.handlers/deploy.go:64
POST /deploy starts a rollout; the daemon boots from
cmd/deployd.cmd/deployd/main.go:30
surface coverage
covered against a deterministic spine — routes, flags, env vars, models, state — every citation resolved to file:line.
Named gaps — what the docs don't cover yet
POST /deploy/rollback handlers/deploy.go:212 DEPLOY_CANARY_PCT config/env.go:48 Measurably complete — not "the AI wrote something". Atlas regenerates the gaps until coverage clears your threshold.
A git repo (public, or private with a token) or a Jira project. Optional branch, subpath, include/exclude globs.
git · jira Atlas extracts the real surface — routes, flags, env vars, models, state — then drafts grounded, cited pages and publishes the tree.
spine → draft → publish A cheap probe checks for drift about every 15 minutes; on your schedule it regenerates only the sources that actually changed.
hourly · daily · weekly Your tokens stay yours
git and Jira tokens are named, reusable credentials owned by a user or an org — write-only over the API, never written to a page or a log. Lend a private-repo token to an org project without putting it in a shared pool; nothing's left behind if you leave.
In the loop with your agents
Atlas is reachable over MCP, too — atlas_list_projects, atlas_run,
atlas_run_status let an agent in Claude or ChatGPT kick off and check a run, not
just read the result.
Two source types today — git and Jira. More are coming. We name what Atlas reads rather than imply a catalog it doesn't have. Atlas needs an LLM endpoint and an embedder — both on for the hosted instance; self-hosting, you point it at your own.
See how Atlas works →Ask your docs
tela’s own AI answers from your own pages — the ones Atlas wrote and your team maintains — citing every source, and saying so when they don’t cover it instead of guessing.
Ask-your-docs needs an embedder and an LLM — both on for the hosted instance, metered by your plan’s monthly answer allowance; self-hosting, point tela at any OpenAI-compatible model.
The agent layer
Your AI already lives in the chat apps you work in, so tela connects to them — instead of bolting a chat box onto a wiki you'd have to go open. Connect once and the assistant searches your docs, reads and writes pages, and adds comments, limited to what your account can access. Below: the same wiki, answered and edited from both apps — the connector does the work, you never leave the chat.
When a service degrades, the on-call engineer owns the timeline until handoff. Keep this page open during an incident.
tela incident open "api-latency" --sev 2
In Claude or ChatGPT, add tela as a connector.
telawiki.com/api/mcp One sign-in with your tela account. No token to paste.
OAuth 2.1 The assistant searches and edits the wiki, within your permissions.
39 tools Available in the Claude and ChatGPT connector directories. Nothing to install.
Using Claude Code, Cursor, or your own client? Connect to the same address: telawiki.com/api/mcp.
Give an agent a read-only key, or one that can write. A key can be pinned to a single space.
researchsearchread_chunkrelated_pagessuggest_linksget_pagelist_pageslist_backlinksatlas_list_projectsatlas_run_statuscreate_pageupdate_pageadd_commentmove_pagecreate_spaceupdate_spacemanage keysatlas_runThe assistant reads from the wiki and writes back to it, so context carries from one session to the next instead of being pasted in each time. It can also surface related pages, suggest links while writing, and flag overlapping content — and even kick off an Atlas run and check its status — so the knowledge base stays connected and current as it grows.
See the full tool catalog →A real wiki first
Block editing, real-time collaboration, comments, version history, sharing — tela works as a wiki without any of the AI. The Claude and ChatGPT connector is one more way in, not the whole product.
Editor
Block-based editing: drag a block to reorder it, type / to insert headings, lists, tables, callouts, diagrams, and math. Every page is stored as plain markdown you can export at any time. No proprietary format.
Features
Far more than text — and all of it the day-to-day stuff your team actually uses.
tela incident open --sev 2Callouts, toggles, tables, kanban boards, code, math, Mermaid and Excalidraw diagrams, task lists — inserted from a / menu and stored as plain markdown.
Ship checklist
Tag the release, then push the image and re-probeSam
Verify /api/version matches HEAD
Purge the edge cache lastLee
Roll back in one click if it drifts
Several people edit a page at once with live cursors and no save conflicts. Comments stay attached to the text they mark.
Share any page by link, with an optional password and expiry date.
# Incident response
When a service degrades, the
**on-call engineer** owns it.
> [!note] Page @on-call first.
`tela incident open`Every page is a markdown file. Search, diff, and export them; nothing is locked in a proprietary format.
Every change is saved. Compare versions and restore any of them.
Escalate via the [[On-call rotation]] before paging anyone.
Link pages with [[…]]. Every page shows what links back to it.
Wikilinks and backlinks draw a live graph of how your pages connect — for the whole space or around the page you're on.
Mount a space as a local folder over WebDAV and sync it with rclone — work in Obsidian, VS Code, or any editor. Round-trips as plain markdown, attachments and all.
Import a folder of markdown in one step, and export everything at any time.
Presentations
tela makes real presentations — present them live in the browser, or export to PDF, PPTX or PNG. And because tela is agent-native, your agent can build the whole thing for you: ask Claude or ChatGPT to "turn the launch notes into a 10-slide talk" and it does.
Compare
tela documents itself and your agents work it from Claude and ChatGPT — so the honest question isn’t “which wiki,” it’s how it differs from each tool you’d otherwise reach for, and the one thing each still does better.
| Versus | Where tela wins | What it still does better |
|---|---|---|
| Notion | Your docs write themselves — point Atlas at a repo or Jira project and it generates a cited, coverage-checked wiki — over plain markdown you own, that your agents read and write from Claude and ChatGPT. Not a closed block store with a chat sidebar bolted on. | Databases, templates, and all-round polish are years ahead. Want a relational workspace, not a wiki? Use Notion. |
| Confluence | Atlas turns a git repo or a Jira project into a cited, coverage-checked wiki and keeps it fresh; agents search and write it by meaning; and it’s portable markdown you can run yourself — no enterprise install, no per-seat pricing. | Deep two-way Jira workflow integration (tela documents from Jira; it doesn’t drive Jira), granular permissions, and governance at thousand-user scale. Atlassian shops have reasons to stay. |
| Obsidian | Built for a team and for agents: Atlas-written docs, semantic retrieval, live multiplayer, SSO and roles, and an MCP connector — not a single-player vault you sync by hand. | Local-first single-user is its whole point; the plugin library and graph view are unmatched. Solo? Hard to beat. |
| Notion AI / “AI” wikis | tela generates the wiki from your sources and scores its coverage, then lets your own agent retrieve and write it from Claude or ChatGPT, over markdown you can export — a chatbot bolted onto a wiki does neither, and only works inside their app. | One-vendor convenience and a polished in-app assistant, with no embedder to think about. If you only want their chatbot, it’s simpler. |
None of them close the loop tela does: your sources become a cited, coverage-checked wiki, your agents reason over and maintain it from Claude and ChatGPT, and it’s all plain markdown you own — with real-time editing, SSO, roles, and an audit trail.
Security & team
Every space can be shared with your whole organization, opened to a specific team, or kept private to you. People get owner, editor, or viewer access — and an agent connected through Claude or ChatGPT can only ever see what your own account can.
Share a space with your whole organization, limit it to one group, or keep it private to you.
An agent in Claude or ChatGPT only ever sees what your account can. It can’t reach a space you’re not in.
Give each person owner, editor, or viewer access. Access can be added but never silently lowered.
Sign in with the SSO your team already uses. Accounts are email-verified.
For code agents, each key is read-only or read-write, can expire, and can be pinned to one space.
Public links can require a password and an expiry date. Every key request is logged.
tela is open-source and runs on your own server with Docker Compose — your Postgres, your disk, your data. Self-hosting is optional; the hosted instance is ready to use.
Read the docs →# your server, your data
cp deploy/.env.example deploy/.env
docker compose upHonest caveats: orgs are admin-provisioned (not open self-service signup) and social login isn't wired yet — by design for now. The access model is documented and the auth code is open.
Publish
Flip a space to public and it becomes a no-login, magazine-style blog — your docs, changelog, or handbook on the open web, with RSS and SEO built in. Same plain markdown underneath; nothing duplicated, nothing exported.
Pricing
A personal account and every organization carry their own tier. Every plan includes the whole product — Atlas, semantic search, ask-your-docs, and the agent connector. Tiers only change the limits: spaces, storage, how many AI answers a month, and how much Atlas generation you get.
Flagship
Atlas is on every plan — point it at a git repo or Jira project and it writes a cited, coverage-checked wiki and keeps it fresh. Paid tiers raise how much you can generate.
Personal
$0 free forever
Personal notes and trying tela.
$6 /mo
Billed annually — $72/yr, save $24
For power users who live in their wiki.
Organization
$0 up to 5 members
A small team getting started.
$5 per member / mo
Billed annually — $60/member/yr, save $12
A growing team that runs on its docs.
Custom let's talk
SSO, audit, and scale for a big team.
No card to start — every new account gets a 30-day Plus trial, then settles onto your plan.
Every plan includes
Or run it yourself
tela is open source and self-hostable — Docker Compose, your Postgres, your disk, your markdown. No seats to buy and no limits but the ones you set.
Credibility
Backend, frontend, and the MCP server are open. See exactly what runs.
GitHub →telawiki.com runs the same code. Use it before you commit.
Open it →A real MCP connector, submitted to the Claude and ChatGPT directories and versioned against the backend.
How it works →tela is at v0 and usable today. No fabricated logos, no "trusted by thousands" — just the code, a running instance, a connector you can add, and a spec you can read.
Questions
No. Point Atlas at a source — a git repo or a Jira project — and it reads the source, drafts cited markdown pages, scores them against the source’s real surface (a coverage %, with the gaps named at file:line), and publishes them as ordinary tela pages. Two source types today; more coming. You can still write and edit pages by hand alongside the generated ones.
Atlas probes each source for drift about every 15 minutes (a cheap no-clone check) and regenerates on a schedule you set — hourly, daily, weekly, monthly, or off — rebuilding only the sources that actually changed (a delta run over the changed files). Generated pages are the machine-maintained layer, so a re-run rewrites them. Atlas needs an LLM and an embedder — both on for the hosted instance; bring your own on self-host.
Yes. tela runs a remote MCP server with OAuth sign-in; add it as a connector in Claude or ChatGPT (it’s submitted to both directories) and your agent searches, reads, and writes your wiki — scoped to your account. Code agents like Claude Code or Cursor point at the same URL with a token.
tela ranks results by meaning as well as by keyword, so a search returns the section that answers your question even when it doesn’t contain the exact words. Your team searches from the command palette; Claude and ChatGPT search the same way through the connector and get a link back to the source.
Yes — that’s “ask your docs”. Ask in plain language and tela retrieves the relevant sections and writes an answer with citations to the source pages, grounded only in what your account can read. If your docs don’t cover it, it says so instead of inventing an answer. Agents ground their answers the same way through the connector.
Only if you self-host. Meaning-based search needs an embedding model, and ask-your-docs also needs an LLM — point tela at your own of each (the hosted instance has both set up). Keyword search always works on its own.
Yes. The editor is full block editing — drag, slash menu, turn-into, tables, diagrams — but pages.body is plain markdown. There is no block table; reordering a block reorders markdown lines. Import a directory, export anytime.
Yes. Mount a space as a local folder over WebDAV and sync it with rclone, then edit the files in any editor you like. Pages round-trip as plain markdown and non-markdown files (images, PDFs, diagrams) sync too — so your local folder and tela stay in step both ways.
Through the Claude and ChatGPT connectors they sign in once with OAuth — no token to handle. For code agents like Claude Code or Cursor, you create an access key that’s scoped to read or write, can expire, and can be limited to a single space.
Yes — SSO, organizations and groups, and per-space roles (owner / editor / viewer) with hard invariants. Keys are scoped and audited. The access model is documented and open.
There’s a free tier for personal use and for small teams, paid Plus and Team tiers above them, and Enterprise for scale — or self-host it free. Tiers change limits (spaces, storage, and monthly AI answers), not features, and every new account starts on a 30-day Plus trial. Full breakdown on the pricing page.
Yes. It’s open and self-hostable with Docker Compose (Postgres, plus an optional embedder for semantic search and an LLM for ask-your-docs). Your data on your disk, your markdown exportable. Self-host is the option, not the requirement — the hosted instance is ready to use now.
Start free on the hosted instance, or self-host it yourself.
Free to start · markdown you own · self-host whenever you want