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 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 limits you set. You add it with a frontend change, and your backend stays as it is.

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's 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 and checked against it as it changes, so the agent works from current facts                       |
| Observability     | Every conversation, tool call and approval is recorded, so your team can see what users asked for and what the agent did              |

## The parts

| Part           | What it is                                                                                                                                             | Where it's covered                |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------- |
| Knowledge      | The product docs your agents work from, drafted from your connected code and verified as the code changes                                              | [Knowledge](/knowledge)           |
| Agents         | Each agent's instructions, model and grants: which knowledge, actions and tools it may use                                                             | [Agents](/agents)                 |
| Actions        | Your API operations, registered in a catalog with a policy each: run freely, ask the user first, or never. They run in the user's browser, as the user | [Actions](/actions)               |
| App access     | Reading the page the user is on, filling in forms and navigating your app                                                                              | [App access](/app-access)         |
| Assistant UI   | The interface in your product, added with an npm package or a script tag                                                                               | [Assistant UI](/assistant-ui)     |
| Administration | Your organization, members, keys and billing                                                                                                           | [Administration](/administration) |

You don't need every part 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.

## 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 |

Teaflask never holds credentials for your API. Actions run in the user's browser with their own session, so your API applies the same permissions it applies to everything else that user does.

## More resources

- [How Teaflask connects to your app](/architecture) – the parts of a live integration and where the boundary sits
- [Grounding](/grounding) – what the agent bases its work on, and the limits on what it can do
- [Getting started](/getting-started) – from a connected repository to a live agent in your product
- [Glossary](/glossary) – the terms used throughout these docs