Thousand

Thousand is a documentation engineering platform that provides git-backed docs for both humans and AI agents. It is built around a single markdown repository that supports folder-level access control, so every reader gets a workspace shaped exactly like their permissions. The product is designed for teams that want their documentation to serve a post-AI workforce, where teammates, outsiders, and AI agents all interact with the same source material. Thousand positions markdown as the document format, ensuring that a human reads the same bytes as a document that an agent reads as markdown. There is no export step and no second copy that can drift from the original. The platform addresses a fundamental limitation of markdown and git when used for documentation alone. Git traditionally shares all or nothing, which means access control at the folder or path level is not natively supported. At the same time, half of a typical team will never open a terminal, yet they still need to read and edit documentation. AI agents introduce another class of reader that requires programmatic access with expiring credentials. Thousand solves these problems by adding path-level access control on top of a markdown repo, enforcing rules even for readers who never touch git. It also provides a document editing experience for non-technical teammates while preserving clean markdown on disk. A core capability of Thousand is that one file is first-class for both readers. A teammate sees the markdown as a formatted document, while an agent reads the same bytes directly. This eliminates export and prevents copy drift. The platform enforces path-level access control through access rules. For example, admins can be granted write access everywhere, a design folder can be writable by a specific person, an engineering folder by another, a notes folder readable by an agent named summarizer-bot, and a marketing folder readable by the team. If no rule matches a path, the content remains hidden. These rules are enforced for all readers, regardless of whether they use git. Thousand can sync every codebase’s context into one place. Each repository’s docs folder mirrors into the workspace on every commit, read-only and stamped with its source. Because nobody maintains a copy, the documentation never rots. For teammates who never open a terminal, Thousand offers a document editor that lets them edit markdown without seeing markdown. They write in a familiar interface, but the file on disk stays clean markdown, and every save becomes a named commit. Any document can also be sent to someone who has no account: it becomes a link that opens in their browser, requiring no sign-up on their side, while the owner retains a revoke button. Comments in Thousand never touch the document file itself. Threads live beside the document, not inside it, and are saved as markdown that a clone carries too. This keeps the source clean while preserving discussion context. The platform also handles decks and PDFs: Office files and PDFs render in place and are searchable by what they say, not just by filename. Beyond prose, Thousand supports drawings and tables as first-class files in the repo. An Excalidraw canvas or a CSV table opens ready to edit under the same access rules as everything else, so structured and visual content remains governed by the same permissions model. An agent is treated as a member of the workspace, not an add-on. A bot gets its own name, its own folders, and a token that always expires. The profile card acts as a preflight check, showing exactly what the agent can access. Tokens are shown once and die with the agent. A Thousand workspace can also tidy itself: duplicates, stale drafts, and dead ends get swept out on a schedule, but nothing is removed without a human merging the change. Thousand keeps company with your remotes. It acts as one more remote on the same repo, so it works alongside GitHub or GitLab without conflict. For agents, the site answers markdown when requested, serving /AGENTS.md instead of a page built for eyes. Thousand’s approach is fundamentally git-backed and markdown-native. The workspace is a git remote: you can add it to an existing markdown repo, push, and retain history. Access rules are defined per folder or path, and the platform filters what each reader sees. Humans interact through a document editor or a reading view, while agents interact through tokens and markdown endpoints. The same repository powers all readers, with access control enforced at the path level. This means the repo remains the single source of truth, and the platform adds boundaries without creating a proprietary format or a separate copy of the content. The primary benefit is that documentation can serve both people and agents without sacrificing control or cleanliness. Teams avoid exporting content or maintaining duplicate copies, so documentation does not drift. Non-technical teammates can contribute without learning git or markdown syntax. External sharing is simple and revocable, with no account required for the recipient. AI agents get scoped access with expiring tokens, reducing security risk. The self-tidying workspace keeps documentation current by surfacing duplicates and stale files for human review. Because the repo is yours, there is no lock-in: a git clone yields the same files, same history, and same markdown. Concrete use cases include internal team documentation such as budgets, forecasts, and board notes, where folder-level access ensures only the right people see finance or legal content. Engineering teams can mirror codebase docs from multiple repositories into one workspace, keeping context synced on every commit. Marketing and design teams can collaborate on pricing pages and assets with comment threads that stay beside the document. Companies can share decks or PDFs with external parties via revocable links. AI agents can be given read access to specific folders for tasks like summarization, while their tokens expire automatically. Teams already using GitHub or GitLab can add Thousand as an additional remote without disrupting existing workflows. Thousand is for teams that rely on markdown documentation and need real access control, especially those working alongside AI agents. It suits organizations where some members are highly technical and others never open a terminal. Integration points include GitHub and GitLab as remotes, and agents that consume markdown via HTTP with an Accept header. The tech stack centers on markdown and git, with support for Office files, PDFs, Excalidraw canvases, and CSV tables as repo files. Pricing is free while Thousand is early, and the exit policy is explicit: git clone is always the whole exit. In summary, Thousand provides documentation engineering with plain markdown, real boundaries, and one clone to leave, making it a git-backed documentation platform for a post-AI workforce.