# Teaflask

> Teaflask is the AI layer for software products. It puts an agent inside your product that carries out work for your users: it runs multi-step workflows, changes records through your own API, fills in forms and moves users to the right screen, answering their questions along the way. It acts as the signed-in user, within policies you set. You add it with a frontend change, and your backend stays as it is.

Teaflask is built on one belief: nobody wants to click buttons. Every menu, onboarding tour, buried settings page, and "how do I…" support ticket is a tax your users pay to reach an outcome they already decided on. Teaflask removes that interface tax by putting an agent inside your product that operates it on the user's behalf. This is what we call the **agentic frontend**: your product stops being an interface people must learn and starts being an outcome they simply ask for.

Teaflask is backed by Y Combinator.

## What Teaflask is

Teaflask is a hosted platform for running an AI agent inside a SaaS product. Unlike a chatbot that only answers questions and points users at help articles, the Teaflask agent gets the task done: it calls your existing API as the user, works with the page the user is on, and follows your own procedures. Answering questions is included; the point is that it does the thing.

Calling a model is the small part of shipping an agent inside a product. Teaflask runs everything around it:

- **Durable execution.** Long-running tasks survive crashes, deploys and dropped connections, and pick up where they stopped.
- **Streaming.** Replies and tool activity stream to the user as they happen, and resume after a reconnect.
- **Scaling.** The agent runtime is hosted and scales with your traffic. There is no chat backend to build or run.
- **Guardrails.** Grants, policies and approvals decide what each agent may do. Every action runs as the user, through your API's own permission checks.
- **Interface.** An assistant you embed in your product, themed to match it, with your own components for results.
- **Knowledge.** Product docs drafted from your code, with checks for claims the connected code can establish and proposed corrections for owner review.
- **Observability.** Every conversation, tool call and approval is recorded, so your team can see what users asked for and what the agent did.

The platform has six parts, and you do not need every one to start. An agent with knowledge and no actions already answers questions about your product; actions and app access are added one at a time, each with its own policy.

- **Knowledge.** The product docs your agents work from, drafted from your connected code, with verification for checkable claims.
- **Agents.** Each agent's instructions, model and grants: which knowledge, actions and tools it may use. You try it in a playground and publish it; your users get the published revision.
- **Actions.** Your API operations, registered in a catalog with a policy each: Allow (run without asking), Ask (the user approves first) or Deny (never). They run in the user's browser, as the user.
- **App access.** Reading the page the user is on, pointing out a control, filling in forms and navigating your app.
- **Assistant UI.** The interface in your product: a corner widget, a command palette and a full-page view, added with the `@teaflask/assistant` npm package or a script tag, themed to match your product, with your own components for results.
- **Administration.** Your organization, members, keys and billing.

## How it works

1. **Connect your repository.** Install the Teaflask GitHub App and choose the repositories it may read. The access is read-only. From your code, Teaflask can draft docs, check covered claims in released docs through active verification suites, and discover the API operations and pages your agents can use. Everything it finds is a proposal you review.
2. **Build the knowledge.** Draft docs from your code or write them yourself, then release them. Agents read released docs only, never drafts.
3. **Register actions.** Scan your code for API operations, approve the ones you want in the catalog, and give each a policy: Allow, Ask or Deny. A common start is Allow for read-only operations and Ask for anything that changes data.
4. **Configure and publish an agent.** Write its prompt, choose its model, grant it knowledge, actions and app access, try it in the Playground, then publish.
5. **Install the assistant.** Create a publishable key and mount the assistant once, in the layout that wraps every page: `npm install @teaflask/assistant` for React, or one script tag for any other stack. A small actions adapter in your frontend sends the agent's requests to your API with the user's own session.

## What makes Teaflask different

- **It acts, it doesn't just answer.** The agent completes tasks through your own API and your own pages (multi-step workflows, record changes, form filling, navigation) rather than pointing users at documentation.
- **It runs as the user, through your permissions.** Actions run in the user's browser with their own session, so your API applies the same permission checks it applies to everything else that user does. Teaflask never holds credentials for your API.
- **Guardrails are enforced, not requested.** The runtime enforces grants and policies before a request leaves it. An action set to Ask never reaches the browser without the user's approval, and a denied action is never offered to the model at all. The model only ever sees the tools the agent is granted.
- **Knowledge checked against code.** Docs can be drafted from your code. Release requests checks for claims the code can establish; after a suite's initial success, relevant production-branch pushes can trigger re-checks. A contradiction can lead to a proposed revision for an owner to release. It never changes a released page on its own.
- **Hosted and durable.** The agent runtime, the model calls, the conversation history and the guardrails run on Teaflask. Turns survive crashes, deploys and closed tabs.
- **A frontend change, not a rebuild.** Your product keeps its data, business rules, API and authentication. You add a component or a script tag, then configure the published agent, allowed origins and the integrations your workflows need.

## What Teaflask runs and what you own

| Teaflask runs | You own |
| --- | --- |
| The agent runtime, the model calls and the conversation history | Your product's data, business rules and API |
| The guardrails on what each agent may attempt | What each of your users is allowed to do |
| The embeddable interface | Where it appears and how it looks |
| Keeping your docs checked against your code | What the docs say, and when changes are released |

## Reliability and scale

Teaflask is production infrastructure, built to run inside live products under real traffic.

- **Durable turns.** Accepted, funded messages start durable turns on the Teaflask runtime. Runtime work can survive a closed tab, dropped connection, crash or deploy and recover from the last recorded round. Browser-dependent steps wait for an open conversation. Recorded browser requests are not replayed; if a page closes mid-request, the outcome is recorded as unknown rather than retried. This is not a guarantee of exactly-once completion in your backend. A message refused for lack of funding has no turn to resume.
- **Pauses that wait.** When a turn needs the user, for an approval or a question, it pauses. If nothing answers, it parks and resumes when the answer arrives, even much later.
- **Streaming that resumes.** Replies and tool activity stream as they happen, and a dropped connection picks up where it left off. Any number of tabs can show the same conversation at once.
- **Scaling.** The agent runtime is hosted and scales with your traffic.
- **Model fallbacks.** Each agent has a model and can have fallbacks. The runtime can fall back when a provider is throttled, overloaded or down, or when the model that took over can no longer serve the message because its context capacity or funding source changed.
- **Observability.** Every conversation, tool call and approval is recorded, so your team can see what users asked for and what the agent did.
- **Enterprise operations.** SAML single sign-on, an uptime SLA and dedicated support on Enterprise plans.

## Who Teaflask is for

Teaflask is for software companies that want an AI agent inside their product without building and running one in-house. It is a strong fit for vertical SaaS (software for care management, transport and logistics, travel, accounting, and field services) and for teams that need enterprise controls such as SSO and SLAs.

## The problem Teaflask solves

SaaS products force users to learn an interface to accomplish anything. That interface tax shows up as support tickets, low feature adoption, onboarding drop-off, and documentation that is always out of date. The obvious fix, an agent that just does the task, has been hard to reach: a chatbot that only answers is not enough, an agent that acts without understanding the product is unsafe, and building a durable agent runtime is a major engineering project. Teaflask solves this with knowledge drafted from the code and verified against it (so the agent has product-specific evidence), actions that run through the product's own API as the user (so it gets outcomes done, within the user's own permissions), and policies that gate what the agent may attempt (to constrain the operations it may attempt).

## Use cases

- **Resolve support questions** with answers grounded in your real product, not stale FAQs.
- **Drive feature adoption** by walking users straight to the outcome, or doing it for them.
- **Onboard users** by doing setup steps for them.
- **A general in-app agent** for any task a user would otherwise perform by clicking through the UI.

## Trust and security

Every request answers three questions, each with its own mechanism.

- **Which agent replies?** A publishable key in your page. It is public by design and serves only the origins listed for it.
- **Who is asking?** An end-user token your backend signs, if you identify users. The signing secret never leaves your server. Without one, the visitor is anonymous.
- **What may be done?** The agent's grants and each action's policy on the runtime, then your backend's own permission checks.

The user is identified twice, and the two never cross. The end-user token tells the runtime who the user is and never reaches your backend. The user's session in your product is what your backend checks when an action runs, and it never reaches Teaflask. Teaflask holds no credentials for your backend.

The models your agents run on do not train on your data. Security documentation and compliance evidence are published at the [Trust center](https://trust.teaflask.com).

## Pricing

- **Free, forever.** The full platform, not a trial: one agent, hosted docs, verified knowledge, and the embeddable assistant. The only bill is the model. Bring your own Anthropic or OpenAI key, buy credits at the model's list price with 0% markup, or let your users connect the ChatGPT subscription they already pay for.
- **Enterprise.** Unlimited agents, docs on a custom domain, SAML SSO, an uptime SLA, a forward-deployed engineer and deployment strategist, and a dedicated Slack channel. Annual contract; book a call.

## Category and vision

Teaflask is building the **agentic frontend**: a future where users no longer navigate interfaces but state outcomes, and an embedded agent gets them done. As end users increasingly bring their own AI agents, products that let agents accomplish tasks will win, and products that still require a human to learn a UI will lose. Teaflask is the layer that makes a software product legible and operable by agents: the vendor's own agent and, over time, the user's.

## Documentation

- [Docs](https://docs.teaflask.com/): the product documentation. Every page is also served as Markdown at the same path with `.md` appended.
- [Docs index for agents](https://docs.teaflask.com/llms.txt): every documentation page as a Markdown link, grouped by section, with a one-line description each.
- [How Teaflask works](https://docs.teaflask.com/fundamentals): what Teaflask is, what it runs and what you own.
- [Architecture](https://docs.teaflask.com/architecture): where each part runs, how a turn moves forward, the trust model, and what data goes where.
- [Grounding](https://docs.teaflask.com/grounding): what the agent bases its work on, and the controls on what it may do.
- [Getting started](https://docs.teaflask.com/getting-started): from a connected repository to a live agent in your product.
- [Install](https://docs.teaflask.com/install): getting the assistant onto every page of your app, step by step.
- [Assistant UI](https://docs.teaflask.com/assistant-ui): how the embedded assistant behaves inside your page.
- [@teaflask/assistant on npm](https://www.npmjs.com/package/@teaflask/assistant): the React components and custom elements.
- [@teaflask/assistant on GitHub](https://github.com/teaflask/assistant): the package's public repository.

## Links

- [Home](https://teaflask.com/): product overview and positioning.
- [How it works](https://teaflask.com/how-it-works/): where the agent runs, and the four steps that put it in your product.
- [About](https://teaflask.com/about/): mission, principles, and the people behind Teaflask.
- [Pricing](https://teaflask.com/pricing/): free forever, the model is the only bill, enterprise.
- [Resources](https://teaflask.com/resources/): the collection of guides, comparisons and explainers on embedded AI assistants.
- [Blog](https://teaflask.com/blog/): notes from the team.
- [Changelog](https://teaflask.com/changelog/): what changed in Teaflask and when, told plainly.
- [App](https://app.teaflask.com/): the Teaflask dashboard: connect a repository and ship an agent.
- [Trust center](https://trust.teaflask.com/): security documentation and compliance evidence.
- [Privacy policy](https://teaflask.com/privacy/): how Teaflask handles data for customers and for end users of the embedded assistant.
- [Terms of use](https://teaflask.com/terms/): the rules for using the teaflask.com website.
- [Customer agreement](https://teaflask.com/agreement/): the terms of service customers accept at signup.
- [Cookie policy](https://teaflask.com/cookies/): the cookies and browser storage each Teaflask surface uses.


## Resources

- [Embedded AI assistants for SaaS: a buyer’s guide](https://teaflask.com/embedded-ai-assistants/): The layers, product categories and questions to ask before choosing a platform.
- [Code-grounded AI assistants: a buyer’s guide](https://teaflask.com/code-grounded-ai-assistants/): Code indexing, source refreshes, documentation drafting and claim verification.
- [CopilotKit and Vercel AI SDK alternatives](https://teaflask.com/copilotkit-ai-sdk-alternatives/): A layer-by-layer comparison with assistant-ui, ChatKit and Teaflask.
- [AI assistant UI](https://teaflask.com/ai-assistant-ui/): Installation, surfaces, theming and interface boundaries.
- [Codebase grounding for AI assistants](https://teaflask.com/codebase-grounding/): Repository evidence, released documentation, executable checks and reviewed corrections.
- [Durable execution for AI agents](https://teaflask.com/durable-execution/): Pausing for approval, recovering recorded progress and handling unknown request outcomes.