Getting Started with teaflask

teaflask is the AI concierge for SaaS companies. It reads your codebase, writes documentation grounded in what your code actually does, and then keeps that documentation provably in sync with the product — every claim traced back to code and re-checked as the code changes. On top of those verified docs, it builds AI agents that answer your customers' questions and can resolve tickets.

This guide explains what the product does and walks a brand-new user through their first session.

What teaflask is for

Most documentation drifts: the product changes, the docs don't, and nobody notices until a customer hits the gap. teaflask is built to make that impossible. Its core loop is:

1. Connect your sources — point teaflask at a code repository.
2. The AI drafts docs — grounded strictly in your real code, citing what's actually there.
3. The AI also writes the proof — for every doc, it compiles the doc's factual claims into an executable verification suite (one check per claim).
4. A human approves — you review and release a draft; nothing goes live silently.
5. The suites re-run as reality changes — when the code contradicts a claim, that failure becomes a reviewable drift proposal, not a silent lie.

The result is documentation that shows its receipts. Trust is demonstrated — you can see why a doc is believed (which claims are verified, and when they last passed) — rather than just asserted with a green checkmark.

Who it's for

The people building in teaflask are technical — developers first, alongside engineering, product, and customer-support teams. They prompt teaflask to create and maintain docs for their codebase, and build AI agents (for example, customer-support chatbots) wired to those docs.

There's a second audience one step removed: whatever you publish is consumed by everyone — end customers, support agents, and AI assistants alike. The builders are technical; what they publish must work for anyone.

What you can do in teaflask

Once you're set up, the dashboard gives you a set of connected surfaces:

• Copilot (the dashboard home) — teaflask's own embedded assistant, answering from your docs. It's the same assistant your customers get, used here on your own product, and it's pinned as the first row of the workspace rail. It wears the name Copilot in the workspace because Assistant is the name the customer-facing agent under Agents already carries.
• Docs — the workbench for your knowledge base: the doc list and folders, the doc editor, revision history, and drift proposals. Each doc has a Re-verify action and freshness status so you can see its verification state at a glance.
• Reviews / Requests — a "waiting on you" queue for work that needs your approval.
• Agents — customer-facing AIs wired to your verified docs and the skills you grant them, with install/embed instructions, run history, and a playground to test them.
• Skills and Actions — the capabilities your agents can use. Actions are your own API endpoints an assistant may call on a user's behalf; every proposed action waits for your approval before it can ever run.
• Conversations — a read-only, org-wide view of the threads your agent has served, so you can monitor what it actually said.
• Help Center — your released docs, served publicly to your customers at a hosted help site.
• Settings — your account, organization members, billing, and integrations (where you connect GitHub).

How verification works, in plain terms

When you publish a doc, teaflask turns its factual claims (like "the cancel button says 'Cancel plan'") into a doc provenance verification suite — code that checks each claim against your actual repository. A verification run is one execution of that suite. The last time a doc's suite passed cleanly is its provenance.

When the code changes and a claim no longer holds, teaflask doesn't quietly edit the doc. Instead it opens a drift proposal: the editor shows a banner quoting the falsified claims, and while a fix is being drafted it tells you "Verification failed — a fix is being drafted." You review the proposed correction and decide.

Getting started

1. Sign in

Sign-in is passwordless. You can sign in with Google or with an emailed code. (In a local development build there's also a Sign in as dev user button that signs in a seeded account.)

2. Onboarding wizard

A brand-new sign-up is walked through a short setup wizard. The steps, in order:

1. What should we call you? — set the display name teammates see on your work.
2. Create your organization — "Your docs, your agent, and your teammates live inside it."
3. What do you want out of this agent? — pick a goal: a co-pilot for your users, deflecting support tickets, or driving feature adoption.
4. Connect your codebase — link a GitHub repository (see below). Read-only, and you can skip it for now.
5. Scan for actions — optionally let the agent read your API for actions it could take on your users' behalf. Every proposal waits for your approval before it can run.
6. Bring your docs — start fresh; once your codebase is connected, the agent drafts your first doc from your code.
7. Watch your first doc get written — give it a prompt and it drafts doc #1 live, citing your code. Your welcome credit covers it.
8. Meet your agent — a playground pane where you can ask your agent anything and see it answer from your docs.
9. Install the assistant — answer where the assistant will live, and teaflask mints the publishable key and an install prompt for you.

3. Connect a GitHub repository

teaflask reads your product's reality from your code, so connecting a source is the key step. Go to Settings → Integrations, open the GitHub card, and choose Connect GitHub.

Connecting installs the teaflask GitHub App with read-only access. Importantly, you choose which repositories are in scope on GitHub, not inside teaflask — teaflask just reads and displays the resulting list. The connection guarantees are spelled out during setup:

• Read-only — the agent reads the repositories you choose and can never write to them.
• You pick the repositories — selection happens on GitHub, and you can change it there any time.
• No stored tokens — access is minted on demand through the GitHub App; nothing sits in a database waiting to leak.

After connecting, the GitHub page shows the installation account and the in-scope repositories. To add or remove repositories later, change the installation's access on GitHub. You can Disconnect GitHub from teaflask at any time — teaflask stops reading the repositories, while the app stays installed on GitHub.

4. Write your first doc

With a repository connected, ask teaflask for a doc. The drafting agent reads your actual code and writes a draft grounded strictly in what it finds — it never invents APIs, config flags, or filenames. Review the draft, and release it when it's right. From there, its verification suite keeps it honest as your code evolves.

5. Install the assistant on your product

When you're ready to put the assistant in front of your customers, teaflask gives you a publishable key and an install prompt. The key is safe to include in your page source, and the assistant only answers requests from the origin (website URL) you specify — you can add more origins later from the agent's Install page.

Where this is heading

teaflask ships verified docs, a hosted help center, an embeddable assistant, and the agents/skills/actions/conversations surfaces described above. The stated forward direction — not yet built — is a single ChatGPT-style chat bar through which you do anything in the platform (the AI does the driving and the screens exist to verify its work), and agentic frontends offered as a service for any product.