Thousand

Thousand is a documentation engineering platform that stores docs as plain markdown in a git repository, then shapes a separate workspace for every reader based on their permissions. It is built for teams whose documentation must serve two very different audiences at once: people who want to read and edit a normal document, and AI agents that need clean markdown they can parse. Every folder in the repo knows its own audience, so a teammate, an outside guest with no account, or a bot with a token each sees exactly the folders their rules name and nothing else. The company describes it as git-backed docs for humans and agents, in one markdown repo with folder-level access. The problem Thousand addresses is that markdown is the document, yet markdown alone could not do certain things. Git shares an entire repository all or nothing, so there was no straightforward way to give one person finance and another person design while keeping everything else hidden, especially for readers who never touch git. Teams ended up copying the same content into a separate document tool, which created a second copy that could drift from the source of truth. Meanwhile agents needed machine-readable text, and the pages built for human eyes had to be scraped, converted, and exported. Thousand's premise is that one file should be first-class for both readers: your agent reads the markdown, your teammate reads the same bytes as a document, with no export and no second copy to drift. Path-level access control is the core of the product. Instead of sharing a repo all or nothing, each folder in Thousand has its own rules. In the example shown on the site, admins get write access, the design folder is writable by one person, the notes folder is readable by a summarizer bot, the marketing folder is readable by the team, and when no rule matches a folder it stays hidden. These rules are enforced even for readers who never touch git, so access is real rather than convention. Access can be extended outside the company too: any document becomes a link that opens in the browser for someone with no account, with no sign-up required on their side and a revoke button on yours, plus a record of how many times the link was opened. Half of a team will never open a terminal, and the site acknowledges that directly: for them it is just a document. Thousand lets people edit markdown without seeing markdown, writing in a document editor while the file on disk stays clean markdown and every save becomes a named commit. Comments follow the same philosophy: threads live beside the document rather than inside it, and they are saved as markdown that a clone carries too, so feedback never pollutes the file's content. Decks and PDFs live in the workspace as well, rendering in place and remaining searchable by what they say rather than only by filename. Drawings and tables are not excluded either: an Excalidraw canvas or a CSV table is simply a file in the repo, so it opens ready to edit under the same access rules as everything else. Agents are treated as members of the workspace, not add-ons. A bot gets its own name, its own folders, and a token that always expires; the profile card acts as the preflight, showing exactly what the agent can read and what stays hidden. The workspace also tidies itself: duplicates, stale drafts, and dead ends get swept out on a schedule, and nothing is removed without a human merging it. Thousand keeps company with existing remotes, described as one more remote on the same repo, so it works alongside GitHub or GitLab without a conflict, with one repository and three remotes and nothing moving. Finally, agents get their own copy of a page: when asked for markdown, the site answers markdown, so agents can read a dedicated file instead of scraping a page built for eyes. The overall approach is that documentation lives once, in markdown, inside a git repository that the customer owns, and everything else is a filtered view on top of it. Each repo's docs folder mirrors into the workspace on every commit, read-only and stamped with its source, so nobody maintains a copy and it never rots. A reader's workspace is then shaped exactly like their permissions: the same underlying bytes produce a document view for a person, a markdown response for an agent, and a hidden folder for anyone whose rules do not name it. Commits are the unit of change, whether they come from a developer pushing to a remote, a colleague saving in the document editor, or a bot signing in by token. The site summarizes this as documentation engineering: plain markdown, real boundaries, one clone to leave. The stated benefits follow from that design. Access is real rather than conventional, so sensitive folders such as finance can stay hidden from people and agents who should not see them, even in history. Context from every codebase can be synced into one place, meaning documentation stays current instead of rotting in separate tools. Non-technical teammates can contribute without learning markdown or git, because the editor hides the syntax while preserving the file. Feedback arrives as comments that never touch the file, so a clone carries the threads without altering the document itself. Because the repo is yours and exit is a single git clone, adoption carries no lock-in: after cloning, you have the same files, the same history, and the same markdown. Pricing is described as nothing while Thousand is early. Concrete scenarios from the site include a team writing a Q3 budget in a finance folder, where the numbers table, renewals list, and next steps are read as a document by colleagues while an agent reads the same bytes as markdown. An engineering org can mirror each repo's docs folder into the workspace on every commit so API server and web app context sit in one place. A designer or operations person can edit a pricing page in the document editor while a thread about whether it holds if trials convert slower stays beside the file. Someone can share a Q3 deck with an outsider as a link that opens in a browser with no account, track that it was opened three times, and revoke it later. Agents can sign in with an expiring token to read only the notes they are allowed, and an office deck, a PDF, an Excalidraw diagram, or a CSV of vendors can all be stored, rendered, and searched alongside prose. Thousand is aimed at teams working in what the site calls a post-AI workforce, where colleagues and agents share the same documentation. That includes technical teams who already keep markdown repos and want real access boundaries, and non-technical teammates who will never open a terminal but still need to read and edit the same files. Outside collaborators and guests are supported through links that require no account. Integrations are framed as remotes: Thousand is one more remote on an existing repository and works alongside GitHub or GitLab. The stack is deliberately plain, built around markdown and git, with Excalidraw drawings and CSV tables stored as ordinary files. Getting started is a Google sign-in, and an existing markdown repo can be added as a git remote and pushed, history and all. Pricing is nothing while Thousand is early, and git clone is always the complete exit. Thousand's value proposition is that documentation can serve humans and agents from a single markdown repository while still enforcing real boundaries. One file works for both readers, each folder knows its audience, every save is a named commit, and agents participate as members with expiring tokens. Because the repo belongs to the team and clones out cleanly, the platform adds structure and access control without locking anyone in. Documentation engineering, as Thousand frames it, is plain markdown, real boundaries, and one clone to leave.