# Tale

> The orchestration layer for AI agents — local AI models, agents, skills, and workflows on your own infrastructure.

## Cloud

- [Billing](https://tale.dev/docs/cloud/billing.md): What Tale Cloud charges for, how budgets stop runaway costs, and where the bill shows up in the product.
- [Data residency](https://tale.dev/docs/cloud/data-residency.md): Where your Cloud data lives, where it moves during a single chat, which sub-processors touch it, and what stays in region versus what leaves.
- [Cloud](https://tale.dev/docs/cloud.md): Tale Cloud is the managed edition. Tale runs the stack, your data is pinned to Switzerland or the EU, and your team's only operational task is using the product.
- [Migrate to self-hosted](https://tale.dev/docs/cloud/migrate-to-self-hosted.md): When self-hosting beats Cloud, what moves and what does not, and how to carry your org across without breaking running agents.
- [Cloud onboarding](https://tale.dev/docs/cloud/onboarding.md): From demo request to a production-ready organization — get your own instance from the Tale team, create the org, invite the first admin, add a model provider, publish an agent, open chat.
- [Trust and compliance](https://tale.dev/docs/cloud/trust-and-compliance.md): Which compliance posture Tale Cloud ships with, who audits what, which controls are yours, and how to report incidents.

## Develop

- [AI-assisted development](https://tale.dev/docs/develop/ai-assisted-development.md): How Claude Code, Cursor, Copilot, and Windsurf edit a Tale project — the rules file each editor reads and the schema reference Tale generates under `.tale/reference/`.
- [API reference](https://tale.dev/docs/develop/api-reference.md): How to call Tale from outside — authentication, endpoints, error model, rate limits, and the OpenAI-compatible chat endpoint. The single source of truth for the Tale API surface.
- [Contributor setup](https://tale.dev/docs/develop/contributor-setup.md): The single source of truth for setting up Tale's source for local development — prerequisites, bun install, the pre-flight check, what bun run dev does, port conflicts, and the pre-PR checklist.
- [Integrations](https://tale.dev/docs/develop/integrations.md): Building custom integrations — REST connectors, SQL databases, MCP servers — and where each one fits next to the shipped integration catalogue.
- [Develop](https://tale.dev/docs/develop/overview.md): Develop covers the API-consumer surface — REST API, webhooks, integration SDK, AI-assisted development workflow, status page, rate limits.
- [Rate limits](https://tale.dev/docs/develop/rate-limits.md): REST API rate limits — default per-key budgets, per-org caps, the 429 response shape, and how to retry without making things worse.
- [Status page](https://tale.dev/docs/develop/status-page.md): Tale's public status page — what it covers, how incidents are scoped per service, where the RSS feed lives, and how the page differs from your self-hosted metrics.
- [WebDAV API](https://tale.dev/docs/develop/webdav-api.md): Protocol reference for Tale's WebDAV server — URL scheme, authentication, supported methods, property list, lock semantics, and limits.
- [Webhooks](https://tale.dev/docs/develop/webhooks.md): Inbound webhook triggers (you POST to Tale) and outbound event webhooks (Tale POSTs to you). Signing, idempotency, retries.

## Start here

- [Your first day running a workspace](https://tale.dev/docs/get-started/admins.md): The admin journey — create the workspace, connect an AI provider, bring in the team, and know where governance lives.
- [Your first day integrating with Tale](https://tale.dev/docs/get-started/developers.md): The developer journey — mint an API key, make your first authenticated request, and know where the API surface lives.
- [Your first day building agents](https://tale.dev/docs/get-started/editors.md): The editor journey — create an agent, give it instructions and a model, make it visible in chat, and watch it answer.
- [Your first day using Tale](https://tale.dev/docs/get-started/members.md): The member journey — chat with an agent, give the workspace a document to know, and find your way around projects and chat history.
- [Quickstart](https://tale.dev/docs/get-started/quickstart.md): From nothing to your first agent answer — get an instance, sign in, and send your first message. Five minutes on a ready instance, fifteen if you stand one up on your own machine.
- [Tale documentation](https://tale.dev/docs/index.md): Tale is the orchestrator for AI agents. Start with the quickstart, follow the get-started journey for your role, or jump into the feature reference.

## Platform

- [Agents (admin view)](https://tale.dev/docs/platform/admin/agents.md): The org-wide agents list — every agent in the organisation, who built it, which model it runs, what knowledge it touches. Admins and Owners read this when they govern agents across the whole org rather than build one of their own.
- [API keys](https://tale.dev/docs/platform/admin/api-keys.md): Org-wide credentials that let external code call Tale's REST API on behalf of the organisation. Admins and Developers create, rotate, and revoke them under Settings > API keys.
- [Branding](https://tale.dev/docs/platform/admin/branding.md): Logo, favicon, and the accent colour your organisation shows to its members. Admins read this when whitelabelling a self-hosted instance or aligning the in-product chrome with the company palette.
- [Changelog](https://tale.dev/docs/platform/admin/changelog.md): The in-product release viewer that surfaces what changed in the Tale platform itself. Admins read this after an upgrade to see what landed and to share the highlights with the org.
- [Enterprise SSO and provisioning](https://tale.dev/docs/platform/admin/enterprise-sso.md): Configure single sign-on (OIDC, OAuth2, SAML 2.0) and SCIM user and group provisioning for your organisation. Step-by-step setup for Microsoft Entra ID, Google, generic OIDC, and SAML, plus role mapping, group-to-team sync, and deactivation. Read this when wiring enterprise identity for the org.
- [Audit logs](https://tale.dev/docs/platform/admin/governance/audit-logs.md): The chronological log of who-did-what across your organisation — sign-ins, role changes, provider edits, agent edits, run-code invocations. Admins and Owners read this when an audit asks who touched a resource and when.
- [Content and models](https://tale.dev/docs/platform/admin/governance/content-models.md): Model-level controls — which models are allowed per role or team, and the default model each user group lands on. Admins and Owners read this when a compliance rule pins a workload to an approved model or when a team needs a cheaper default.
- [Data subject requests](https://tale.dev/docs/platform/admin/governance/data-subject-requests.md): The GDPR Article 17 workflow for erasing a person's data across chats, documents, workflow runs, and prompts. Admins and Owners read this when a user files a request or when an SLA deadline is closing in.
- [Feedback analytics](https://tale.dev/docs/platform/admin/governance/feedback-analytics.md): Aggregated thumbs-up and thumbs-down on agent messages plus chat ratings, broken down per agent and per model. Admins and Owners read this when an agent regression needs a number behind it.
- [Guardrails](https://tale.dev/docs/platform/admin/governance/guardrails.md): The three filter layers — content safety, PII detection, and a moderation provider — that screen chat inputs and outputs before and after the model. Admins and Owners read this when a regulator names a content rule or when a leak warrants a tighter policy.
- [Legal hold](https://tale.dev/docs/platform/admin/governance/legal-hold.md): The dual-controlled freeze that pauses retention sweeps and erasure cascades for a specific user, document, thread, or the whole organisation during litigation. Admins and Owners read this when counsel asks them to preserve evidence.
- [Policies and limits](https://tale.dev/docs/platform/admin/governance/policies-and-limits.md): Per-org caps on token cost, request count, upload size, image generation, and feature access — scoped by user, team, role, or individual API key. Admins and Owners read this when a workload is over budget or when a feature needs a tighter blast radius.
- [Run-code policy](https://tale.dev/docs/platform/admin/governance/run-code-policy.md): The package allowlist and denylist that gate what sandboxed Run code can install. Admins and Owners read this when an agent needs a new library or when an audit asks why a package was blocked at a given time.
- [Trash](https://tale.dev/docs/platform/admin/governance/trash.md): The soft-delete recovery view for retention-trashed records — chat threads, documents, prompts, workflow runs — before they are permanently deleted at the end of the grace window. Admins and Owners read this when someone needs a deleted artefact back.
- [Usage analytics](https://tale.dev/docs/platform/admin/governance/usage-analytics.md): The dashboard for tokens, cost, and request volume by user, team, model, and agent — with trends and a top-agent leaderboard. Admins and Owners read this when a bill is unexpected or when leadership wants the rough shape of AI spend.
- [Integrations (admin view)](https://tale.dev/docs/platform/admin/integrations.md): Settings > Integrations is where Admins install, configure, and rotate the credentials behind Slack, Gmail, Outlook, Microsoft 365, Google Drive, Confluence, WebDAV, GitHub, Shopify, Tavily, and MCP. This page covers the admin surface, not the per-integration feature list.
- [Members and roles](https://tale.dev/docs/platform/admin/members-and-roles.md): The six roles that ship with Tale and the resource-level matrix that says who can do what. Admins and Owners read this when they set up a team or when an audit asks who has access to what.
- [Admin](https://tale.dev/docs/platform/admin/overview.md): Admin is the configuration plane — members, teams, providers, API keys, integrations, branding, governance. The pages here are what an Admin or Owner clicks through to set up an org and keep it running.
- [AI providers](https://tale.dev/docs/platform/admin/providers.md): Settings > AI providers is where Admins connect the OpenAI-compatible providers behind every reply, choose which models the org may call, and set the defaults. Every reply Tale streams comes from a model resolved through this page.
- [Teams](https://tale.dev/docs/platform/admin/teams.md): Teams are named groups of members that share access to agents, prompts, projects, and integrations. Admins create and manage teams under Settings > Teams; the boundary they draw is the scoping layer for everything below the role layer.
- [Token sources](https://tale.dev/docs/platform/admin/token-sources.md): Settings > Token Sources is where Admins point a bring-your-own-key agent at an external broker that hands out a pool of LLM credentials. The agent draws one token per run and fails over to another on a rate-limit or auth error, so a single throttled or expired key never stalls the run.
- [Two-factor authentication](https://tale.dev/docs/platform/admin/two-factor-authentication.md): TOTP enrolment, passkeys, backup codes, the org-wide enforce policy, and how an admin resets a member who lost their authenticator. Read this when wiring 2FA for the org or recovering an account.
- [Agent folders](https://tale.dev/docs/platform/agents/categories.md): How agents are grouped — folders derived from the agent's id, how automation-installed agents file themselves, and where the permission boundary actually lives.
- [Agent concepts](https://tale.dev/docs/platform/agents/concepts.md): An agent is the four-knob combination of instructions, knowledge, tools, and a model. This page hands you the mental model the rest of the agents section assumes.
- [Conversation starters](https://tale.dev/docs/platform/agents/conversation-starters.md): Authoring the suggested prompts an agent shows on its empty-chat screen — adding, ordering, translating, and the auto-translate action.
- [Create an agent](https://tale.dev/docs/platform/agents/create.md): Walk from the Create agent dialog to a published agent — name it, write instructions, scope its knowledge, grant tools, and verify it in Chat.
- [Agent workers](https://tale.dev/docs/platform/agents/delegation.md): An agent can spawn a focused worker for one task through the spawn_agent tool. This page hands you the mental model for when to spawn, how capabilities stay bounded, and what the job card shows.
- [External agents](https://tale.dev/docs/platform/agents/external-agent.md): Built-in coding agents (Claude Code, Cursor, OpenCode, Hermes Agent, Gemini CLI, Codex, Pi, OpenClaw) that run inside an isolated sandbox; you chat with them directly as they edit files, run commands, and continue the work across turns.
- [Image generation](https://tale.dev/docs/platform/agents/image-generation.md): Image generation as an agent capability — inline images in any assistant's reply, the Generate image tool, the dedicated image agent type, and what they cost.
- [Agent knowledge](https://tale.dev/docs/platform/agents/knowledge.md): The agent's Knowledge tab — retrieval mode, team and organization document scopes, and agent-only uploads, and how they differ from tools and attachments.
- [Agent skills](https://tale.dev/docs/platform/agents/skills.md): A skill is a reusable bundle — a SKILL.md plus optional scripts and references — that agents read at runtime. This page covers when to reach for one instead of longer instructions.
- [Agent tools](https://tale.dev/docs/platform/agents/tools.md): The per-tool permissions an agent carries beyond text generation — the tool categories, the web search modes, and bound integrations and workflows.
- [Agent versions](https://tale.dev/docs/platform/agents/versions.md): The agent editor's History view — every save snapshotted, with a diff against the current version and one-click restore.
- [Agent webhooks](https://tale.dev/docs/platform/agents/webhook-triggers.md): The agent's Webhooks tab — unique URLs external systems POST to so they can chat with the agent without going through the UI, with the token in the URL as the credential.
- [Approval concepts](https://tale.dev/docs/platform/approvals/concepts.md): An approval is a card in the chat that holds an agent's action until you decide. This page names what fires one, the decisions each card offers, and what every decision leaves behind.
- [Configure approvals](https://tale.dev/docs/platform/approvals/configure.md): Where approval requirements are declared — per integration operation, per MCP tool, and built in for writes and workflow changes — and where to see what will ask before it runs.
- [Approvals in workflows](https://tale.dev/docs/platform/automations/approvals-in-workflows.md): Where humans decide around workflows — approving the AI editor's changes to a definition, approving an agent's request to run a workflow, and answering the questions that pause a run.
- [Automation assistant](https://tale.dev/docs/platform/automations/assistant.md): The chat agent scoped to one automation — what it edits directly, what it drafts for you to apply, and how it finds existing automations before building a new one.
- [Built-in automations](https://tale.dev/docs/platform/automations/builtin.md): What each shipped automation does — the inbox trio, the Resolve GitHub issues bundle, the sync and upkeep templates, and the pre-installed packs that run your boards and mentions.
- [Browse and install automations](https://tale.dev/docs/platform/automations/catalog.md): How the Automations catalog works — Installed vs All automations, the side panel a card opens, the install wizard and its preflight, reinstalling and uninstalling, and updating every built-in automation at once.
- [Automation concepts](https://tale.dev/docs/platform/automations/concepts.md): An automation is the installable bundle of integrations, agents, skills, a workflow, and builtin views — and the workflow inside it is how it runs. This page names the pieces, the runtime around them, and when to reach for an automation instead of a lone agent.
- [The workflow editor](https://tale.dev/docs/platform/automations/editor.md): The operating manual for an automation's Editor tab — where its workflow lives, how to run it, how to pause and disable, how to edit, and how the versioned history works. Read this when you are running a workflow day to day, not when you are learning the model.
- [Execution logs](https://tale.dev/docs/platform/automations/execution-logs.md): The per-workflow run history — every execution with its status, timing, and trigger source, expanding into a per-step journal. Read this when a run failed or behaved oddly.
- [Workflow triggers](https://tale.dev/docs/platform/automations/triggers.md): The three ways a workflow starts on its own — Schedules, Webhooks, and Events — what each one carries into the run, and how to pause one without deleting it.
- [Agents in chat](https://tale.dev/docs/platform/chat/agents-in-chat.md): How the agents picker works in Chat — which agents appear, what "Visible in chat" controls, one-shot versus sticky agents, switching mid-thread, and sub-agent calls.
- [Arena Mode](https://tale.dev/docs/platform/chat/arena-mode.md): Side-by-side model comparison inside Chat — how it renders, how to pick the contenders, how verdicts feed feedback analytics, and when to reach for it.
- [Attachments](https://tale.dev/docs/platform/chat/attachments.md): Supported file types, where uploads land, when content is RAG-indexed and when it is pasted verbatim into the prompt.
- [Chat basics](https://tale.dev/docs/platform/chat/basics.md): What happens between you hitting Send and the reply landing — composer, agent pick, model resolution, streaming, citations, and how a chat is stored.
- [Canvas pane](https://tale.dev/docs/platform/chat/canvas-pane.md): When the Canvas pane opens, what gets a Canvas versus inline rendering, and how the Canvas content stays with the chat across visits.
- [Deep research](https://tale.dev/docs/platform/chat/deep-research.md): The Researcher agent — open-ended web research with a live to-do plan, cited sources via Tavily, and a clean PDF report at the end.
- [Chat](https://tale.dev/docs/platform/chat/overview.md): Chat is the everyday entry point — pick an agent, send a message, read the reply. This overview maps the parts of the screen and points to the page that goes deeper on each.
- [Shared chats](https://tale.dev/docs/platform/chat/shared-threads.md): Sharing a chat with others in your organization via a link, forking a shared chat into your own, and the read-only banner the viewer sees.
- [Starters and prompts](https://tale.dev/docs/platform/chat/starters-and-prompts.md): Where conversation starters come from on the empty Chat screen, and how the prompt library lets you save and reuse prompts across chats.
- [Voice mode](https://tale.dev/docs/platform/chat/voice-mode.md): Speaking instead of typing — how the round-trip works, which model handles speech-to-text, which handles text-to-speech, and what the privacy boundary covers.
- [Developer](https://tale.dev/docs/platform/developer/overview.md): Developer is the in-app developer surface — API keys, custom tools, agent webhooks, MCP servers. The pages here are what someone with the Developer role clicks through when they wire Tale to external code.
- [Editor](https://tale.dev/docs/platform/editor/overview.md): Editor is the build surface — creating agents, projects, automations, and the knowledge they reach into. The pages here are what someone with the Editor role does day to day.
- [Platform](https://tale.dev/docs/platform.md): Platform is the canonical product reference — every user-visible feature, identical for Cloud and self-hosted. Chat, projects, agents, automations, knowledge, approvals, admin.
- [MCP servers](https://tale.dev/docs/platform/integrations/mcp-servers.md): Register external tool servers under Settings > API > MCP — transport, authentication, the discovered tool list, and the per-tool approval flags that keep the trust boundary tight.
- [Integrations](https://tale.dev/docs/platform/integrations/overview.md): The third-party systems Tale connects to — the catalog under Settings > Integrations, what each connector does, how connecting works, and how the surface differs from MCP.
- [WebDAV](https://tale.dev/docs/platform/integrations/webdav.md): Mount your organisation's documents as a network drive in Finder, File Explorer, or any WebDAV client — generate an app-password under Settings > API > WebDAV and connect from your device.
- [Crawling](https://tale.dev/docs/platform/knowledge/crawling.md): How Tale turns a website into knowledge — domain registration, sitemap-driven URL discovery, scheduled re-scans, and the indexed-pages view.
- [Documents](https://tale.dev/docs/platform/knowledge/documents.md): The Documents tab is where Editors upload files into the knowledge base, watch them index, and manage their lifecycle — upload sources, RAG status, team scoping, folders, and reindexing.
- [Knowledge entries](https://tale.dev/docs/platform/knowledge/knowledge-entries.md): Knowledge entries are small, topic-keyed facts in the knowledge base — captured from chat with human approval or added by hand — with one live version per topic and full version history.
- [Knowledge](https://tale.dev/docs/platform/knowledge/overview.md): Knowledge is the org's shared library — documents, small facts, crawled websites, and typed records — that agents ground their replies in. This overview names the tabs and points at the per-area pages.
- [Structured data](https://tale.dev/docs/platform/knowledge/structured-data.md): Tale's knowledge base ships four built-in structured entities — Customers, Products, Vendors, Websites — alongside Documents. This page hands you the mental model for when to pick a typed record over a document.
- [Environment variables & secrets](https://tale.dev/docs/platform/member/environment.md): Your personal environment variables and secrets, injected into every agent sandbox you run in an organisation — most often the provider credential a bring-your-own agent authenticates with.
- [Install as app](https://tale.dev/docs/platform/member/install-as-app.md): How to install Tale as a Progressive Web App on desktop and mobile — the menu shortcut on Chromium browsers, the iOS Safari path, and what changes once the app is installed.
- [Member](https://tale.dev/docs/platform/member/overview.md): Member is the end-user surface — chat, browse the knowledge base, reply in an installed automation's Inbox, act on approvals. The pages here are what someone with the Member role does day to day.
- [Preferences](https://tale.dev/docs/platform/member/preferences.md): The member-level settings that follow you across orgs and chats — name and password under Account, theme and locale in the profile menu, custom instructions and memories under Personalization, and sign-out.
- [Model catalog](https://tale.dev/docs/platform/models.md): The model catalog behind every picker in Tale — where it lives under Settings > AI providers, what the capability tags mean, which defaults ship, and how the list stays fresh.
- [Project Backlog](https://tale.dev/docs/platform/projects/backlog.md): Backlog is a board status for proposed work — automations sync issues here, and you move tasks forward with the same drag, status picker, and assignee controls as every other lane.
- [Project concepts](https://tale.dev/docs/platform/projects/concepts.md): A project bundles chats, files, instructions, tasks, and discussions into one shared workspace. This page hands you the mental model for when to reach for a project over a stand-alone chat.
- [Discussions](https://tale.dev/docs/platform/projects/discussions.md): Threaded, multi-participant conversations inside a project — open a topic, talk it through with the team, and bring an agent in with an @mention.
- [Manage project files](https://tale.dev/docs/platform/projects/manage-files.md): The project's Knowledge tab holds the files every chat in the project can draw on — folders, uploading, index status, pinning, and how project files stay scoped to the project.
- [Projects](https://tale.dev/docs/platform/projects/overview.md): A project is a shared workspace that bundles chats, files, instructions, tasks, and discussions around one piece of work. This overview maps the project tabs and points to the page that goes deeper on each.
- [Agents and models in a project](https://tale.dev/docs/platform/projects/project-agents.md): The Agents & models tab curates which agents and models members see inside a project — Recommended pins favourites to the top, Restricted allows nothing else.
- [Task automation](https://tale.dev/docs/platform/projects/task-automation.md): The default task-ops pack — how assigning a task to an agent runs it, the human review gate, guardrails (budgets, concurrency, circuit breakers), and the kill switch.
- [Prompt library](https://tale.dev/docs/platform/workspace/prompt-library.md): The Prompt library is where you save chat prompts for reuse — personal, team, or org-wide. Members, Editors, and Developers read this when they keep a recurring chat starter handy.

## Self-hosted

- [Authentication](https://tale.dev/docs/self-hosted/configuration/authentication.md): The four sign-in modes Tale ships with — local password, Microsoft Entra, generic OIDC, and trusted headers — and how an operator switches between them.
- [Data residency](https://tale.dev/docs/self-hosted/configuration/data-residency.md): Point a self-hosted Tale deployment's knowledge database, application database, and uploaded-file storage at infrastructure you control, configured by administrators in Settings > Data residency and applied on restart.
- [Environment reference](https://tale.dev/docs/self-hosted/configuration/environment-reference.md): Every environment variable Tale reads at boot, the default, and the surface in the product the variable controls. The complete operator reference for `.env`.
- [Observability config](https://tale.dev/docs/self-hosted/configuration/observability-config.md): The env vars and flags that turn on logs, metrics, and error tracking — and what each one routes where.
- [Providers](https://tale.dev/docs/self-hosted/configuration/providers.md): The two-file provider format on disk — `<name>.json` for the public shape, `<name>.secrets.json` for the keys — plus the workflow for adding, swapping, and disabling a model provider.
- [Retention](https://tale.dev/docs/self-hosted/configuration/retention.md): How org-wide retention is configured — operator bounds in env vars and UI controls under Governance for chats, documents, audit logs, and ledger rows.
- [Secrets with SOPS](https://tale.dev/docs/self-hosted/configuration/secrets-with-sops.md): How Tale encrypts provider keys on disk with SOPS and age, the three storage modes, and the full key rotation walk.
- [TLS and domains](https://tale.dev/docs/self-hosted/configuration/tls-and-domains.md): How the Caddy proxy terminates TLS — self-signed for development, Let's Encrypt for production, external for an upstream proxy — plus custom domain and custom certificate setups.
- [Contributing to Docker images](https://tale.dev/docs/self-hosted/contributing-docker.md): How to build and extend Tale's Docker images for forks, vendored builds, or air-gapped distributions.
- [Self-hosted](https://tale.dev/docs/self-hosted.md): Self-hosted Tale runs on your infrastructure — on-premises, in your VPC, or air-gapped. Seven containers, your data on your disk, no per-seat billing.
- [Install the tale CLI](https://tale.dev/docs/self-hosted/install/cli-install.md): Install the tale CLI on macOS, Linux, or Windows — and configure it against your self-hosted instance for deploys and upgrades.
- [Docker Compose reference](https://tale.dev/docs/self-hosted/install/docker-compose-reference.md): Which compose file ships with Tale, what each is for, and how the layering works when you bring up dev, docs, or test combinations.
- [Create the first admin](https://tale.dev/docs/self-hosted/install/first-admin.md): Walk a brand-new self-hosted instance through its one-time setup wizard — first account becomes Owner with no key, new people join by invite, and the admin key is only for the Convex dashboard.
- [Install](https://tale.dev/docs/self-hosted/install.md): Pick the right Tale install path — a laptop trial with the CLI, a hardened production install on a Linux host, or the raw Docker Compose reference for full control.
- [Production Linux server install](https://tale.dev/docs/self-hosted/install/linux-server.md): A hardened Linux install on a single host — TLS via Let's Encrypt, firewall, non-root user, and the operational hooks to put real traffic on.
- [Self-hosted quickstart](https://tale.dev/docs/self-hosted/install/quickstart.md): Get a working Tale instance running on your machine — install the tale CLI, then two commands, and the setup wizard makes you the Owner.
- [Backups and restore](https://tale.dev/docs/self-hosted/operate/backups-and-restore.md): Volume snapshots via `tale backup`, the automatic pre-migration snapshot, retention, the off-host copy, and the `tale restore` drill.
- [Container architecture](https://tale.dev/docs/self-hosted/operate/container-architecture.md): Which container owns which job in a running Tale instance, the request path of a chat message, and what an outage in each container looks like.
- [Operations](https://tale.dev/docs/self-hosted/operate/observability/operations.md): What to alert on, which metrics matter, and the oncall checklist when a Tale instance starts behaving badly.
- [Prometheus and Grafana](https://tale.dev/docs/self-hosted/operate/observability/prometheus-grafana.md): A copy-paste Prometheus and Grafana stack that scrapes Tale's two metrics endpoints, plus a starter dashboard and a first alert rule.
- [Troubleshooting](https://tale.dev/docs/self-hosted/operate/observability/troubleshooting.md): Symptom-first index for the issues operators have actually hit on Tale instances — what the user reports, what is broken, and what to do about it.
- [How to read release notes](https://tale.dev/docs/self-hosted/operate/release-notes/format.md): The shape Tale's release notes follow — the semver promise, where breaking changes and deprecations sit, how security entries are flagged, and where the per-release migration notes live.
- [Security advisories](https://tale.dev/docs/self-hosted/operate/security/advisories.md): The Tale security advisory feed — CVE format, the four-tier severity scale, the disclosure timeline maintainers commit to, and how to subscribe.
- [Audit-log integrity alerts](https://tale.dev/docs/self-hosted/operate/security/audit-log-integrity.md): How to respond when the daily audit-log integrity check raises an alert — reading the finding, telling tampering from a benign configuration gap, and preserving evidence.
- [Cryptography](https://tale.dev/docs/self-hosted/operate/security/cryptography.md): The algorithms Tale uses for data at rest, data in transit, password hashing, and audit-log integrity — and how they map to BSI TR-02102-1.
- [Hardening](https://tale.dev/docs/self-hosted/operate/security/hardening.md): The hardening checklist for a production Tale instance — non-root user, firewall, TLS, secret storage, audit-log retention, backups.
- [tale-daemon](https://tale.dev/docs/self-hosted/operate/tale-daemon.md): Run task work on your own machines with local coding-agent CLIs (Claude Code, Codex) — setup, pacing, isolation, permissions, and failure handling.
- [Upgrades](https://tale.dev/docs/self-hosted/operate/upgrades.md): How `tale update` moves a Tale instance forward — automatic CLI/instance version alignment, the rolling restart pattern, what to do before an upgrade, and the version compatibility story.
- [Self-hosted architecture](https://tale.dev/docs/self-hosted/overview.md): Eight containers, one compose file, two Postgres databases. This page hands you the mental model for what each container does, where data lives on disk, and which secrets matter at first boot.

## Tutorials

- [Connect a local LLM provider](https://tale.dev/docs/tutorials/admin/connect-local-provider.md): Wire a local Ollama, LM Studio, or vLLM server into a self-hosted Tale instance, allowlist its models, and verify that agents reach it without leaving the host network.
- [Pipe meeting transcripts into the Knowledge Base](https://tale.dev/docs/tutorials/admin/meeting-transcription.md): Wire Meetily (or a similar local meeting-transcription tool) into a Tale project's Knowledge Base so transcripts land as documents on their own without anyone uploading a file.
- [Install the Outlook add-in](https://tale.dev/docs/tutorials/admin/office-add-in.md): Roll out the Tale sidebar inside Outlook and Microsoft 365 so members can draft replies with Tale agents without leaving their inbox.
- [Build a custom tool](https://tale.dev/docs/tutorials/developer/build-a-custom-tool.md): Package a custom function as a tool that agents can call, then attach it to an agent and watch it appear in tool calls during a chat.
- [Call Tale from a script](https://tale.dev/docs/tutorials/developer/call-tale-from-a-script.md): Mint an API key and call the Tale REST API from a bash, Python, or Node script — the smallest end-to-end path from terminal to agent reply.
- [Stand up an MCP server from scratch](https://tale.dev/docs/tutorials/developer/mcp-server-from-scratch.md): Wire a Model Context Protocol server as a custom integration so any Tale agent in the org can call its tools.
- [Trigger a workflow via webhook](https://tale.dev/docs/tutorials/developer/trigger-automation-via-webhook.md): Add a webhook to a Tale workflow and POST to its URL from an external system to start a run with idempotency.
- [Build an agent with knowledge](https://tale.dev/docs/tutorials/editor/agent-with-knowledge.md): Bind documents from the knowledge base to a fresh agent so its replies cite the documents instead of guessing from the model's parametric memory.
- [Hand work to a worker](https://tale.dev/docs/tutorials/editor/delegate-between-agents.md): Ask the assistant for open-ended research, watch it spawn a focused worker, and follow the job card — live progress, the result, and the full transcript.
- [Build your first agent](https://tale.dev/docs/tutorials/editor/first-agent-end-to-end.md): Walk a fresh org from "I want an agent" to a working chat reply by turning the four knobs — instructions, knowledge, tools, model — in order on one instance.
- [Build a workflow with an approval](https://tale.dev/docs/tutorials/editor/workflow-with-approvals.md): Have the AI editor build a three-step workflow where a human decision sits between the draft and the send, approve its proposal, then run it end to end and inspect the journal.
- [Chat effectively](https://tale.dev/docs/tutorials/member/chat-effectively.md): Five habits that turn a chat from "thanks for the wall of text" into "exactly what I needed" — naming the agent, picking the model, attaching the right file, asking in scope, and reading the citations.
- [Use projects to bundle files and chats](https://tale.dev/docs/tutorials/member/use-projects.md): Turn a one-off chat into a shared workspace that keeps the same files, instructions, and conversations together — and stops you from re-uploading the same documents every time.
- [Tutorials](https://tale.dev/docs/tutorials/overview.md): Role-indexed task walks — Member, Editor, Developer, Admin. Each tutorial takes a fresh instance from "I want to do X" to a working result.

## Legal

- [Privacy policy](https://tale.dev/docs/legal/privacy.md): What Tale collects, why, how long it is kept, who else processes it, and the rights you have over your data.
- [Subprocessors](https://tale.dev/docs/legal/subprocessors.md): The third-party processors Tale Cloud uses to deliver the service, what each one processes, and where the processing happens.

## Optional

- [OpenAPI specification](https://tale.dev/docs/develop/api-reference.md)
- [GitHub](https://github.com/tale-project/tale)