The transparency layer for AI-authored work

Docs your team can actually see.

Glassdocs turns a Markdown repo - docs/*.md plus a mkdocs.yml - into a published, access-gated knowledge base on your own Cloudflare. A browser extension lets anyone chat with a page and commit an edit straight back to GitHub. Whoever wrote the work - a teammate or an AI agent - the docs are what your team reads, approves, and holds future work to.

The problem

Most software is shipped faster than anyone can read it.

AI accelerated this, but the underlying problem is older: a codebase is only as transparent as its documentation, and documentation is the first thing teams cut. The result is a system your team owns on paper but can't fully see.

Blackbox

Code your team did not read

An inherited service. A junior's first PR. A 3 AM hotfix from six months ago. AI-authored work, today. Different sources, same outcome - you ship code your team can't fully explain.

Friction

Fixing a doc takes a checkout

The reader who spots the stale sentence is rarely set up to fix it. Clone, branch, build, PR - most fixes die at step one, and the page stays wrong for the next reader too.

No memory

Every change starts from scratch

Whether the next contributor is a teammate or an AI prompt, they rediscover your codebase. No record of what was decided, no record of what was already accepted. Each change reinvents context.

Exposed

Private docs are hard to publish safely

Internal and client-facing docs need a real gate, not an unlisted URL. Most teams either never publish at all or trust a static host that was never locked down - one misstep from public.

The loop

Whoever writes, your team approves, future work follows.

Three roles, three verbs. The loop runs the same whether the writer is a teammate, a contractor, or an AI agent. The docs are the contract for what is in your codebase.

1

Whoever writes, documents

Every change lands with documentation - Markdown pages in docs/, committed alongside the code. One commit carries both the work and the human-readable explanation of what happened.

2

Your team reads and approves

The docs publish as a real site your team reads - searchable, navigable, gated to exactly the people you name. Edit what is wrong, approve what is right. The accepted version becomes the record of truth.

3

Future work follows the docs

The next contributor - human or agent - reads the approved docs before touching code, and the extension keeps them one side panel away from wherever the work happens. The docs become the contract: current, findable, and in force.

How it works

Markdown in your GitHub. A gated site in your Cloudflare.

  1. 1

    Create a KB from the template

    A knowledge base is a plain GitHub repo: docs/*.md pages plus a mkdocs.yml for nav and theme. Generate it from the Glassdocs template; the admin dashboard walks you through provisioning and connects Cloudflare with one paste.

  2. 2

    Push - your CI publishes it

    Your GitHub Actions builds the Markdown with Zensical and deploys it to your own Cloudflare Pages behind Cloudflare Access. Fail-closed: set a staff domain and optional client grants, or nobody gets in. World-readable docs are an explicit public: true opt-in.

  3. 3

    Chat with any page

    The Glassdocs extension attaches an AI side panel to any published page that names its source repo. Ask about what you're reading, with the page as context. No API key needed - the managed backend runs the AI, or bring your org's own key.

  4. 4

    Edit from where you read

    Switch to Edit mode and describe the change. The AI drafts it, you review the diff, and Apply opens a pull request or commits directly - attributed to your own GitHub identity, republished through the normal pipeline.

docs/auth/session-flow.md
<!-- Written 2026-04-23. Approved by @maintainer. -->
# Session flow

Sessions are issued as signed cookies.
Rotation happens on every privileged action.

## Invariants

- No token in localStorage.
- Cookie is httpOnly and SameSite=Lax.

<!-- Published page emits:
  <meta name="source-repo" content="acme/payments-kb"> -->
The sharpest application

Especially useful when AI is shipping your code.

AI accelerates the opacity crisis. You prompt, code appears, nobody fully read what shipped. Glassdocs applies the same loop to AI work as to human work - the agent documents what it built in Markdown, your team reviews and accepts, and the next session starts from what you accepted.

Agent writes

Documentation as part of the change

Whatever your AI builds comes with a Markdown doc page in the same commit. No separate "now write the docs" step. Documentation is part of finishing the work.

You approve

The docs are the diff you read

Reviewing AI-written code line by line is impractical at the volume agents ship. Reviewing the doc that explains the change is faster and surfaces what actually matters.

Agent reads

Approved docs feed the next prompt

The next agent session starts from the approved docs as context - the record of what your team accepted, not a guess reconstructed from the code. The contract follows the work.

Glassbox

No more shipping a blackbox

The result is a codebase your team actually owns - readable by humans, available to future agent work, audit-friendly by default. The blackbox becomes a glassbox.

Make your codebase legible.

Publish your first KB from the admin dashboard, install the extension, and the next docs page your team reads will answer questions and take edits. Free to start.