> For the complete documentation index, see [llms.txt](https://help.tellius.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.tellius.com/whats-new/release-6.3.md).
# Release 6.3
Tellius 6.3 is here. The context your analysts carry in their heads is now encoded in a skills layer they control. Tune how Kaiya writes, charts, and reasons, without touching a system prompt or filing a ticket. The tab-switching between Salesforce, Slack, and your BI tool is gone, so your field team starts asking Kaiya questions from Salesforce or Slack/Teams without opening another tab. The ten-minute path from a raw data source to a live analytical conversation means new users who started recently stop waiting and start asking on day one. And when they land on the homepage, the work that matters is already waiting: briefings delivered, recent context preserved, team resources surfaced. Read on to find more:
* You can now build agentic workflows conversationally by describing them (akin Kaiya Apps and Kaiya Architect).
* The redesigned homepage surfaces scheduled mission outputs, recently viewed content, and personalized suggestions based on what your team is already using.
* New user onboarding takes a user from a fresh login to a live Kaiya conversation in about ten minutes, with starter questions waiting for them when they arrive.
* Skills gives admins a way to tune Kaiya's behavior for a specific user base without editing system prompts.
* The Kaiya browser extension brings Kaiya into any web page as a side panel. Veeva, Salesforce, internal portals โ the answer is always one keystroke away.
* Slack and Teams integration lets users mention @Kaiya in any channel and trigger missions with slash commands.
There is more in 6.3 beyond the flagship features, so dig in.
### ๐ New features
### Build Kaiya Missions conversationally
You describe what the workflow should do, Kaiya drafts the steps, and execution starts from the same thread.
The **Chat pane** on the left shows the conversation thread and the **Mission Steps pane** on the right displays the full step sequence with type badges and real-time execution state. Each step is individually editable, so you can modify a step's logic mid-session and re-execute. When execution completes, a **Summary tab** appears alongside the **Mission Steps** tab, rendering the full generated output.
#### **How it works in practice**
1. Describe. Tell Kaiya what the workflow should do.
2. Review steps. Kaiya drafts a sequence of steps. You refine the draft conversationally and approve.
3. Execute. The workflow runs. Clarification cards appear in the thread when a step needs an input.
4. Schedule. Set a recurrence, or trigger the workflow from a sample query.
5. Deliver. The output lands as a PPTX, PDF, DOCX, or email.
#### **Mission Draft Editor**
Once a mission is created, it lives in a dedicated editor with three tabs:
**Last Briefing.** Displays the output of the most recent run. Each iteration is shown step by step (Input Collection, SQL Query, Python Analysis, Summary) with a checkmark on each completed step and the full rendered output below, including tables, charts, and narrative text. Follow-up questions are auto-generated at the end of every briefing, giving users a path to drill deeper without starting a new mission. A **"What to do next"** bar offers two actions: **Create App** (convert the briefing into an interactive Kaiya App) and **Create new schedule for Mission** (set up a recurring cadence for automatic delivery).
**Configuration.** A left-hand navigation panel organizes the mission into six sections: Basic Information, Knowledge Sources, Mission Steps, Triggers, Schedule, and Outputs. The **Mission Steps** panel lists every step with a type badge (Input, SQL, Python, Summary) so the step composition is visible at a glance. Each step has a pencil icon for inline editing directly in the conversation.
**History.** For scheduled missions, a run log showing every execution the mission has produced, most recent first. Total Runs, Success Rate, and Average Duration are displayed, giving an immediate health check. The history table lists each run with its job name, status, start time, end time, duration in seconds, a short summary of the output, and the logged timestamp.
#### **What is different now**
* **Interactive execution.** Clarification cards appear during the run. If a step needs a date range, a territory filter, or a metric choice, Kaiya prompts for it at the point in execution where that input is required.
* **Variable passing.** Parameters flow across steps automatically. State produced in one step (for example, a list of underperforming territories or a derived metric) is available to later steps without manual configuration.
* **Trigger from queries.** Workflows surface in the conversation under the "Kaiya Mission" label, so a query can be converted into a recurring workflow.
* **Inline tabs.** The previous configurations for triggering, scheduling, and generating output all move out of dialogs and into inline tabs in the conversation thread.
#### **Output formats**
Completed missions deliver output as PPTX, PDF, or DOCX. For scheduled missions, the artifact in the selected format is automatically emailed to configured recipients once the workflow completes.
{% hint style="warning" %}
Existing missions remain available and are labeled "Classical Editor". The classical editor remains available for existing missions; subsequent releases will transition users fully to the conversational interface.
{% endhint %}
Export generation for mission outputs now runs as a background job with pagination support, so large outputs are processed without blocking the conversation thread. Progress is tracked in the background, and the user is notified when the artifact is ready for download.
### Homepage redesign: A home that learns your workflow
The Tellius homepage has been redesigned so that the new home surfaces what matters right now: outputs from scheduled missions, recently accessed content, and personalized suggestions based on what others in the same Business View environment are using.
#### **What's on the new home page**
* Briefings. Outputs from scheduled Missions are delivered directly to the home screen.
* Recently Viewed. The home picks up where the user left off, surfacing apps, Vizpads, and conversations the user was last working on.
* Suggested for You. Surfaces high-interaction resources across the workspace: shared Vizpads, Missions, and Apps that other users are actively engaging with. This is a rename and continuation of the Trending tab from previous releases.
#### **Adaptive by day, personalized by use**
The homepage adapts to where you are in the lifecycle.
* **Day 0 - New user.** User without data sources or Business Views. When a user logs in and has no configured data sources or Business Views, they are routed to Kaiya Architect to connect a source and conversationally build their first Business View.
* **Day 1 - Getting started.** Starter briefings and suggested content appear, curated to the Business View the user just created. Apps shared by the team surface immediately.
* **Day 30+ - Power user.** The full personalized content library is in place: briefings, recents, activity-based suggestions, and shared team resources in a single view.
{% hint style="warning" %}
A lightweight homepage version is available for customers who do not have Kaiya enabled. KPI pinning is deprecated. Favorites remain available.
{% endhint %}
The platform-wide font family has been updated as part of the homepage redesign, bringing typographic consistency across all modules and pages.
### New user onboarding: From data source to first App in ten minutes
New users without existing data sources or Business Views can now move directly from a fresh login to a live Kaiya conversation, with starter questions auto-generated from the new Business View. There is no blank screen, no manual configuration, and no need to find a starting point on the user's own.
#### **The Day 0 flow**
A new user is routed into **Kaiya Architect** on first login. From there:
1. The user configures a data source. The data connection can be setup directly from the Architect chat, with real-time validation as connection details are entered.
2. The user builds a first Business View through the **Kaiya Architect** conversation.
3. An **"Open in Kaiya"** link appears once the Business View is published.
4. Kaiya opens with six auto-generated starter questions waiting in the thread. The starter questions are generated from the newly published Business View, so they reference real dimensions, metrics, and entities the user just configured.
* **Conversation continuity.** When a Business View is built or updated during the onboarding flow, the Kaiya thread compacts and reloads with the latest Business View state, so the conversation reflects the current schema.
* **Source lock.** Once tables are selected in Data Architect, the underlying data source is locked. This prevents a user from accidentally switching the source mid-workflow and producing inconsistent results.
### Skills: Make Kaiya yours without touching core prompts
In 6.3, the context capabilities that make Kaiya behave like *your team* โ Skills, Phrase Learning, Query Learning, and Memory โ are now unified under a single tab: the **Context**.
Skills let you tune how Kaiya writes, charts, and reasons without editing the underlying system prompts. A skill encodes user-specific preferences (formatting rules, summary style, chart conventions, analytical framing, query patterns, chart rules, narrative style) and Kaiya applies them automatically during conversations. Skills are configured at the **deployment (tenant) level, not per individual user**: once a skill is published, it changes Kaiya's behaviour for everyone in that tenant.
#### **The four layers of context**
The Domain Reasoning Layer organizes context across four pillars. Each pillar represents a different way Kaiya absorbs and applies your team's context:
| Layer | Stage | What it captures |
| ------------------- | --------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Skills** | Layer 1 ยท Taught | Domain ontologies, investigation approaches, and business logic. Pre-built with Kaiya, extended by what you teach it about your domain. |
| **Phrase learning** | Layer 2 ยท Defined | Phrase-level patterns Kaiya learns from your team's vocabulary. Business terms, synonyms, and shorthand mapped to the data model. |
| **Query learning** | Layer 3 ยท Confirmed | Query patterns Kaiya has confirmed from your feedback. Preferred queries, business rules of thumb, what "good" looks like. |
| **Memory** | Layer 4 ยท Compounding | Compounding context Kaiya carries across sessions. The longest-tail layer; gets richer the more your team uses the system. |
The **All Layers** view shows the full context graph with elements across all four layers, joined and continuously refining together.
#### **Inside the Skills layer: four context layers**
When you open the **Skills** tab, the left **Context Layers** panel shows the four layers that feed Kaiya's reasoning for a request, from the foundational platform instructions through to your tenant's own skills:
* **System Prompt.** The base instructions Kaiya uses when planning and summarizing. It is read-only reference, and it is split into two sub-layers: the **Implementation Layer** (the core tool calls and platform functionality that make Kaiya operate correctly across the platform) and the **Behavioural Layer** (Kaiya's default behaviour, which super users can tune when platform-wide behaviour needs adjusting).
* **Business View Context.** The schema, grain, and vocabulary passed to Kaiya with the active Business View. It is set by the workspace and is read-only here.
* **Domain Skill.** Industry-specific rules and defaults, curated by Tellius and shipped with the platform (described below).
* **Custom Skill.** Your tenant's own skills, authored from the specific requirements of your deployment (described below).
### Kaiya Browser Extension: Ask Kaiya on any web page
The Kaiya browser extension brings Kaiya into any web page as a persistent side panel. Analysts who live in Salesforce, Veeva, internal portals, or web-based spreadsheets no longer need to switch tabs to ask a question.
{% hint style="danger" %}
The extension reads the open page and then matches that to a Business View. It answers only when Tellius holds the data behind what's on screen (a Tellius Vizpad, or a third-party dashboard whose data is also in Tellius)
{% endhint %}
* **Context-aware.** The extension detects the active page and auto-selects the most relevant Business View for the context.
* **Highlight to query.** Select any number or phrase on the page and ask Kaiya about it. The selection is passed into the conversation as context.
* **Full Kaiya capability inside the panel.** Missions, Deep Insights, Apps, and PPTX export all run from the side panel.
* **SSO and zero re-login.** The extension inherits the user's existing Tellius session, so there is no separate login for the side panel.
* **Capture screen.** Pass a screenshot of the current page into the conversation as visual context, so Kaiya can reason about what's on screen.
* **Voice input.** Dictate queries directly to the side panel.
### Slack and Teams Integration: Kaiya in the channels you already use
Many data questions surface in Slack or Teams. In 6.3, a Kaiya bot can be added to Slack channels and Microsoft Teams channels so users can ask questions and trigger missions without leaving the conversation.
#### **What the bot can do**
* Direct message the bot for individual questions, @mention the bot in any channel it has been added to, or add it to a group conversation so everyone can ask questions and see answers.
* The first time you ask a question in a new conversation, Kaiya presents a data source picker. You can let Kaiya auto-detect the most relevant Business View, manually select one or more specific BVs, or query across unstructured documents (PDFs, text files). The selection persists for the rest of that conversation.
* When a question requires multi-step analysis, Kaiya offers to run a Deep Insight workflow.
* When Kaiya needs more context, it asks clarification questions and presents a dropdown with suggested options. You can select from the dropdown or type answer directly in the thread.
* Follow-up questions in the same thread continue the conversation with full context โ the data source and prior questions carry forward, so users can ask things like "now break that down by product" without re-specifying the BV.
* Every response includes ๐ and ๐ feedback buttons and a **View in Tellius** button that opens the same conversation in the Tellius web app for deeper analysis, dashboard building, or sharing.
* Completed Kaiya Mission briefings can now be delivered to Slack in addition to email. They can be posted to a channel or sent as a direct message. The Kaiya bot must be added to the channel before it appears as a delivery target.
**Slack vs Teams**
The integration supports both Slack and Microsoft Teams with the same core capabilities. A few differences reflect how each platform works:
| Capability | Slack | Teams |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Conversation boundary** | Slack threads. Each thread is a separate conversation. New top-level message starts a fresh conversation. | Continuous chat. Use the **Change Data Source** button to switch BVs mid-conversation. |
| **Response length** | Truncated at 2,900 characters (Slack's 3,000-character limit). Use **View in Tellius** for the full response. | No truncation. Full responses render in Teams. |
| **Account linking** | Credentials configured at the workspace level by an admin. | One-time per-user account linking flow. Each user clicks **Link my Tellius account** on first use. |
| **Adding the bot to a channel** | `/invite @Tellius` in the channel. | Add the Tellius app from the Teams app bar. |
### Kaiya MCP support
Tellius now has a Model Context Protocol (MCP) server, allowing MCP-compatible clients to call Kaiya's reasoning layer as a tool. An MCP client (such as Claude Desktop, an IDE like Cursor, or a custom or partner agent) connects to the Tellius MCP server and queries data through the same Business View definitions, row-level security, and access controls that govern Kaiya elsewhere in the platform. The connecting client does not receive a copy of the underlying data; it issues requests that Tellius resolves against the governed semantic layer and returns results for.
* **Governed access.** Queries issued over MCP resolve against Business Views and respect the same row-level security and metric definitions as the Tellius web application.
* **Client-agnostic.** Works with any client that implements the Model Context Protocol.
* **Admin-provisioned.** Access to the Tellius MCP server requires authentication that a Tellius administrator configures before a client can connect.
## ๐ Enhancements
### Quicker auto-routing in Kaiya
Kaiya's reflection necessity checker has been tuned. Basic queries that don't benefit from a reflection pass now skip it automatically, eliminating a few seconds latency that previously affected simple queries. In practice, only about 25% of basic queries still trigger reflection. There is no user-facing toggle โ routing happens automatically based on the query type.
### **Fix with Kaiya**
In Kaiya Apps, when a query fails, a **Fix it** action appears with the error. Selecting it passes the error into the Kaiya conversation panel, where Kaiya attempts a correction. The corrected output produces a new versioned result, and the original is preserved alongside it.
* The error is the input. No re-typing the question, no describing what went wrong. Kaiya works directly from the failure.
* When something breaks, the platform corrects it in-flow instead of handing the user off to engineering or support.
* It's non-destructive. Every fix is versioned against the original, so users can compare the two, trust the result, and revert if needed.
### **Kaiya Architect on any connected database**
Kaiya Architect could previously create live Business Views only on Snowflake and Redshift; other sources had to be connected outside Tellius and brought in as in-memory. Kaiya Architect now creates both live and in-memory Business Views directly across all supported JDBC databases (Snowflake, Redshift, PostgreSQL, MySQL, SQL Server, Oracle, BigQuery, Hive, Databricks/Delta Lake, Synapse, Dremio, Teradata, and Exasol).
* Ask the agent to add a source and the connection form opens in place; on save, the source's context flows into your conversation. Existing connections can be edited.
* Live table and column browsing per connector, with expanded SQL-dialect validation and a generic datasource configuration layer that reduces connector-specific setup.
* Provide the questions or metrics you need; Kaiya Architect identifies the relevant tables and columns, runs join validation, and assembles a Business View to publish. Once a source is selected for a session it is locked to that source (switch source or edit connection only).
* Once your Business View is built, Kaiya Architect hands you off to Kaiya. Your homepage is seeded with six starter questions auto-generated from the new Business View (spanning Analytics, Deep Insights, and Apps) plus guidance on what to do next.
* Build a Business View from a file uploaded directly in the chat (CSV, TSV, JSON, Excel (.xlsx/.xls), and Parquet). Kaiya Architect detects each file's schema, plans the Business View (including joins across multiple files), and creates the dataset on publish.
* Dynamic parameters for what-if analysis. Absolute, Range, or List input modes, each typed (Integer, String, Double, Date) with a default; the parameters each formula uses are now recorded automatically on publish.
* Per-measure date mapping. Bind each measure to its own date column (e.g. order date vs. ship date), so time filters like "last quarter" resolve against the right date per measure.
### Inline citations
Within a Kaiya **Deep Insights** run, hovering over a numeric result now reveals the underlying dataframe name, the exact SQL query that produced the result, and the row and column counts of the result set. The citation includes the Python aggregation logic where applicable, so users can trace how a specific number was computed. Natural language descriptions of the SQL load asynchronously alongside the result, so the citation is available immediately without blocking the rendering.
### Apps: publishing and versioning
Publishing replaces sharing as the primary distribution model for apps. The publishing flow adds:
* Version pinning. A specific app version can be marked as active so subscribers always see that version when the app refreshes.
* Signed and unsigned URL support. Apps can be distributed via either, depending on the distribution context.
* Public access toggle. A published app can be exposed to external stakeholders through a public access toggle, without setting up separate sharing rules.
Each published App now has its own dedicated Kaiya conversation thread, separate from the source Deep Insight conversation that originated the app. Questions asked inside the App stay scoped to the App's Business View and filters and do not pollute or get polluted by the parent Deep Insight conversation.
### LLM Settings UI
LLM model configuration moves into a dedicated module split into two surfaces: LLM Configuration (where providers and models are defined as named entries) and LLM Assignments (where each Kaiya capability is mapped to a configured model). The new layout replaces the previous inline editing form with a cleaner card-based interface
### Dataset Refresh Performance Improvement
Dataset refresh operations have been optimized for faster processing in 6.3. This reduces the time between initiating a refresh and having updated data available in Business Views and Vizpads, particularly for large datasets.
### Chart Resizing Grid Enforcement
Chart resizing in Vizpads is now constrained to the grid boundary, preventing charts from being dragged beyond the layout edge. Repeated resize warnings are suppressed after the first notification, resulting in a cleaner editing experience when working with dense Vizpad layouts.
### Pivot Table Drag-and-Drop Improvement
The drag-and-drop experience for configuring pivot tables has been refined, addressing interaction issues that could occur when rearranging fields.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://help.tellius.com/whats-new/release-6.3.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.