Skip to content
Console
Try one

    Release Notes

    Track Thalovant product, SDK, MCP, and documentation changes and find the relevant upgrade guidance.

    Use this page to find product changes, supported SDK and MCP releases, and the guide that explains your next step. Older dated entries describe the releases available at that time; use the compatibility table when choosing a version to install today.

    Separate advertising measurement choice — November 12, 2026

    Section titled “Separate advertising measurement choice — November 12, 2026”

    The website and dashboard offer an optional Advertising measurement choice, separate from analytics and off by default. Earlier analytics choices do not enable it. Consented registration measurement counts a newly created email account or a new Google/GitHub account after its required terms and age confirmation. It does not count ordinary sign-ins. Email verification remains a separate step. See optional measurement during signup.

    Existing accounts, SDKs, and MCP clients keep their sign-in behavior; no client upgrade is required for this change.

    Signing in through the browser — November 8, 2026

    Section titled “Signing in through the browser — November 8, 2026”

    A program on a computer with a browser now signs you in through it. The SDK opens the dashboard’s consent page, you select Approve with the session you already have, and the browser hands the answer back to the program on 127.0.0.1. There’s no code to type, and a link or code sent to someone on another computer delivers nothing to the sender. Device login stays for machines with no browser, such as SSH sessions, CI jobs and containers. Its activate page now shows roughly where and when the code was asked for, and approves only from the device’s own network.

    interactive_login and its equivalents pick the browser or a device code for you. They arrive in Python 0.11.0, Node.js 0.11.0, Go v0.15.0, Rust 0.17.0, Kotlin 0.10.0 (not on Android), Swift 0.12.0 (macOS and Linux) and .NET 0.10.0. The MCP server 0.8.0 adds thalovant_begin_browser_login and thalovant_poll_browser_login, which use the browser over stdio and a device login over Streamable HTTP. The Home Assistant integration 0.3.0 links with Link account through My Home Assistant, approved from Home Assistant’s own network, and keeps Link with a code instead. See Signing In And Creating A Client, MCP Server and Link Home Assistant.

    The wake word is “Thalovant” — November 5, 2026

    Section titled “The wake word is “Thalovant” — November 5, 2026”

    Every client now listens for “Thalovant”, detected on the device by Thalovant’s own model, trained on the way speakers of nine languages say the word. It arrives with Thalovant Voice 0.11.0 and the phone apps from version 1.0.6. An older phone app or Thalovant Voice keeps the wake word it shipped with until it updates. To wake on another word, load a model of your own: see Will It Speak My Language? and Where Your Voice Goes.

    Thalovant Voice 0.11.0 also shows a skill’s card on a satellite with a screen, and rings alarms and timers until you stop them. It plays a stream a skill offers and pauses it for a turn, answers at once with a sentence it has said before, and stops mid-answer the moment you say the wake word. On a small board, wake: head_skip_below: 0.01 in voice.yaml cuts the detector’s CPU by a third.

    A note on volume, and a quicker first answer — November 5, 2026

    Section titled “A note on volume, and a quicker first answer — November 5, 2026”

    Thalovant Voice 0.12.0 plays a short note when the volume changes, as a phone does, whichever way the level was moved. 0.12.1 loads each voice when it starts and keeps it warm, so the first question after a restart is answered as quickly as the next; before, a small speaker could take eight seconds over it.

    SkillKit 0.30.0: Python 3.11, and the fallback answers its room — November 5, 2026

    Section titled “SkillKit 0.30.0: Python 3.11, and the fallback answers its room — November 5, 2026”

    SkillKit now requires Python 3.11, which the projects it generates and these guides already asked for. A fallback skill’s reply goes to the message it answers, so a hub that serves two rooms in two languages answers each in its own; a test double that captured speak should capture speak_to. The kit’s own dependency lock takes filelock 4.2, which closes the advisories on the 3.x line for the kit’s development environment; an installed skill still receives filelock 3.x until combo-lock, under OVOS, accepts 4.x. The guides and the quiz tutorial install 0.30.0. See Python and a terminal.

    SkillKit 0.29.2: every satellite gets the layout — November 5, 2026

    Section titled “SkillKit 0.29.2: every satellite gets the layout — November 5, 2026”

    A layout of the skill’s own now travels with every card. 0.29.0 sent its text once per hub process, so a second satellite asking the same skill got a hash it did not have and drew the words instead (0.29.1). A card the satellite would refuse is refused when it is built, with the reason: a layout’s data that is not plain JSON, a picture that is not bytes, a figure or a tap time a screen cannot print. A knowledge service that answers with something other than a document is reported as unavailable instead of failing the turn. See Show a card on a screen.

    SkillKit 0.29.0: cards on a screen, and a word while it looks — November 5, 2026

    Section titled “SkillKit 0.29.0: cards on a screen, and a word while it looks — November 5, 2026”

    A skill can show a card on a satellite with a screen: a title and a body, a list, a forecast, a picture or a layout of its own. The card is attached to the reply with display.showing or speak_to(..., display=card), and a tap on its button comes back to the skill. See Show a card on a screen.

    A lookup that takes a while tells the person where it is looking: open a lookup_notice, and knowledge_reply says “From Wikipedia…” or “Looking it up…” instead of leaving the room silent (SkillKit 0.26.0 to 0.28.0). Folding keeps the marks that spell a letter in Hindi, Thai and Japanese, so those vocabularies match again (0.25.0). See Ask the knowledge service.

    Chat apps in the SDKs and the MCP server — November 3, 2026

    Section titled “Chat apps in the SDKs and the MCP server — November 3, 2026”

    Python and Node.js 0.10.0, Go 0.14.0 and Rust 0.16.0 connect a chat app to a hub from your own code. Read the plan’s allowance, connect a Telegram, Discord, Matrix, Mattermost or Twitch bot, choose where it answers, pause and resume it, and show its status in words a person understands. Matrix, Mattermost and Twitch are in beta. Credentials go in a SecretValue, which never prints. Each SDK page has a Chat Apps section: Python, Node.js, Go and Rust.

    MCP 0.7.0 adds nine chat app tools, plus an opt-in delete. An agent can read the allowance and the bridges, choose the chats, pause, resume and post a test message. No tool takes a bot token, so connecting a bot and replacing its token stay in the console. See Chat Apps on the MCP page.

    Matrix, Mattermost and Twitch bots, in beta — November 3, 2026

    Section titled “Matrix, Mattermost and Twitch bots, in beta — November 3, 2026”

    Chat apps now offer Matrix, Mattermost and Twitch, in beta. Make the bot’s account on the network, enter its settings and credentials under Connections > Add connection > Chat apps, and type the rooms, channels or channel names it answers in. Each beta bot answers when it’s mentioned or replied to, and counts against the same bots and requests as a Telegram or Discord bot. From its drawer you can edit its settings, replace its credentials and change where it answers. The console can’t check a beta bot’s credentials before it starts or send a test message; its state says whether it signed in. Matrix bots answer only in rooms without encryption. See Answer in Chat Apps.

    Your hub answers in Telegram and Discord — November 3, 2026

    Section titled “Your hub answers in Telegram and Discord — November 3, 2026”

    A hub can now answer in the Telegram groups and Discord channels you choose, through a bot you make yourself. Paste the bot’s token under Connections > Add connection > Chat apps, or in a hub’s Chat apps tab, invite the bot, and pick where it answers. In a group or channel it answers when someone mentions it or replies to it, and each person gets their own conversation.

    Requests from a chat count against the hub owner’s daily allowance, and each bot answers at most 500 requests a day, with six a minute per person. Personal memory is off for people in a chat, and a chat can’t control your home. Home, Family, Workspace, Business, Civic and Pilot include 2 bots, Site Pack and Municipality 10, and Private Edge and Enterprise 20; Free has none. See Answer in Chat Apps.

    Thalovant Voice listens for your hub’s words — November 2, 2026

    Section titled “Thalovant Voice listens for your hub’s words — November 2, 2026”

    Thalovant Voice 0.9.0 asks your hub what it can be asked when it starts, and tunes its speech recognition toward the words your hub’s skills use. A request like “what’s the weather like” is less likely to be heard as something that no skill answers. When you add or remove skills, the next start picks up the change. On a Linux or desktop setup that manages its own configuration, models.hints: false turns it off.

    When the hub hears you but no skill matches what you said, Thalovant Voice now says “The hub could not handle that.” instead of “Something went wrong asking the hub”. Nothing is wrong with the hub or the network: rephrase, or check what your hub can be asked. See Something is wrong.

    MCP dependency updates and input validation - October 26, 2026

    Section titled “MCP dependency updates and input validation - October 26, 2026”

    MCP 0.6.6 updates dependencies and is available on npm, GHCR and the MCP Registry. The Node SDK remains at 0.9.9, with the same transports and tool counts.

    Refresh your client’s cached tool schemas after upgrading. UUID inputs now check the UUID version and variant, and memory-list offsets must be safe integers no greater than 9007199254740991. Validation error wording can also change; handle errors by their result, not by matching the message text. See the MCP setup guide for the updated install commands.

    Clearer account verification and recovery — September 22, 2026

    Section titled “Clearer account verification and recovery — September 22, 2026”

    Registration now keeps the inbox instructions on screen, with a new verification email design and a recovery form for missing or expired links. Confirmation pages follow the dashboard theme and show the next step to sign in.

    The additive POST /v1/auth/verify/resend endpoint accepts an email address and returns a generic accepted response. Existing registration and verification request shapes remain compatible. MFA enrollment is now optional on the Free plan; a factor you already enabled is still enforced at sign-in, and paid accounts keep whatever enrollment policy the account has been given. Existing SDK and MCP clients need no upgrade. See account access for resend limits and recovery.

    Managed sessions, inventory and reply claims — September 13, 2026

    Section titled “Managed sessions, inventory and reply claims — September 13, 2026”

    Python 0.7.4, Node, Kotlin, .NET and Swift 0.7.1, Go 0.9.1, and Rust 0.9.0 provide managed hub sessions and presentable inventory/cache models. Sessions preserve subscriptions across connection replacement and avoid replaying requests after an uncertain send. Python’s earlier managed-session Ask retry is removed; an Ask can trigger an action, so applications must decide whether retrying is safe.

    Python also picks up an upstream fix for duplicate inbound events before subscriber callbacks.

    Replies now expose ordered pipeline and skill IDs plus advisory claim status. Fallback-only answers retain their text and success status but are not claimed; unstamped legacy successes remain claimed. These fields do not verify peer identity.

    Inventory caches validate records, use private atomic writes, and preserve the default example language through JSON serialization. Unknown catalogue locale support remains distinct from a known unsupported language. The managed SDKs also share question-detection and inventory conformance cases.

    MCP 0.5.1 adds the shared presentation view to its inventory tool while preserving existing output fields and per-call identity isolation. Embedded C 0.6.1 adds bounded reply-ID extraction and caller-owned claim classification. See the SDK compatibility table and MCP inventory guide.

    Python subscriptions across reconnects — September 13, 2026

    Section titled “Python subscriptions across reconnects — September 13, 2026”

    Python 0.6.11 preserves live on() subscriptions when the connection is replaced. It also fixes races in 0.6.9 that could register a handler twice or restore a closed subscription. Failed registrations stay inactive after later reconnects. Sessions reopened by the underlying library retain their existing listeners without registering them again, preserving the 0.6.10 fix. See the Python SDK guide.

    Kotlin WebSocket connection fixes — September 13, 2026

    Section titled “Kotlin WebSocket connection fixes — September 13, 2026”

    Kotlin 0.6.3 replaces stale WebSocket authorization values with the current identity, including encoded query names, while preserving other query parameters and URL fragments. Connection errors no longer retain credential-bearing network messages or causes. The supported transports and listing APIs are unchanged. See the Kotlin SDK guide.

    Language listings across 270 languages — September 12, 2026

    Section titled “Language listings across 270 languages — September 12, 2026”

    Python 0.6.8, Node, Swift and .NET 0.6.1, Kotlin 0.6.2, Go and Rust 0.8.1, and MCP 0.4.1 use the same thalovant-languages 0.2.1 listing rules. Spanish questions now receive their question mark, regional entries inherit their base language, and complete phrases such as French coupe le son keep their final period. Languages with no known rules remain bare. The listing APIs and transport support are unchanged.

    Install the current versions from the SDK guides. Embedded C remains 0.6.0, with caller-provided slots and transport.

    Node 0.6.0, Go/Rust 0.8.0, Kotlin/Swift/.NET 0.6.0 and MCP 0.4.0 bring the Python sentence-listing feature to the other managed clients. They bundle the same locale data, match regional language tags using OVOS distances, fill sample slots before explicit overrides, and count unique nonempty rendered examples toward limits. Existing raw example methods remain available. See the SDK guides for each language’s call.

    MCP 0.4.0 also handles SIGTERM and SIGINT cleanly in stdio and HTTP modes, including when running as PID 1 in its container. Cleanup has a ten-second failure deadline.

    Python 0.6.7 fixes suppression of repeated OVOS deprecation messages about the hub’s nested location format. This Python-specific logging fix preserves other warnings and leaves protocol and listing behavior unchanged. Embedded C remains at 0.6.0, with explicit caller-buffer rendering and no bundled locale tables.

    Python 0.6.5 adds as_sentence() and HubIntent.examples(sentence=True). Install thalovant[listing] for language-specific punctuation and slot samples from the shared thalovant-languages data package. Omitting the language keeps the selected registration’s locale; regional variants select the nearest registration. Empty or repeated renderings do not consume the example limit. See the Python listing guide.

    SDK Request Helpers And Guarded Configuration Updates

    Section titled “SDK Request Helpers And Guarded Configuration Updates”

    Python 0.6.4 snapshots nested config and personas before merge I/O and copies the request session even without a pipeline hint. The coordinated managed SDKs retain the same caller payload across configuration-conflict retries. Python also raises the Requests minimum to 2.33.0 and cryptography to 50.0.0 to exclude known vulnerable versions.

    Node 0.5.0, Go/Rust 0.7.0, Kotlin/Swift/.NET 0.5.0, embedded C 0.6.0, and MCP 0.3.0 add request language/pipeline/location hints, embedded audio helpers and speakable intent examples to match Python. Managed SDKs bound audio at 4 MiB per clip and 16 MiB per reply; embedded C supplies caller-owned collection primitives. MCP keeps audio bytes out of text and offers separate media blocks through includeAudio.

    The follow-up Node/Swift 0.5.1 and Rust 0.7.1 releases prevent numeric corruption during guarded merges. Node rejects non-finite values and unsafe integers in config and personas; Rust and Swift preserve native integer values and reject floating-point values outside the exact integer range. These checks also cover stored configuration before writing. Use string identifiers for integers beyond your SDK’s supported range.

    Managed configuration update helpers now default to revision-guarded merging, with at most three attempts and retries only on HTTP 412. This requires a compatible API and both hubs:read and paid hubs:write. Existing applications that need full replacement must select the explicit replacement operation. See SDK capabilities and the configuration migration guide.

    Python 0.6.3 fixes lost updates when separate clients merge runtime configuration at the same time. It uses configuration revisions and conditional PUT, rereading and reapplying the original changes on HTTP 412, with at most three write attempts. A compatible API is required; older servers fail without a write. merge=False remains unconditional replacement. See concurrent configuration updates.

    Python 0.6.1 adds request language, pipeline and location options, bounded embedded audio collection, reply-language reporting, and speakable intent examples. The client factory now exposes self_signed, with certificate verification enabled by default. Python 0.6.2 preserves complete-phrase priority when limiting rendered intent examples. Existing shared-runtime skill helpers remain supported. See the Python SDK guide.

    Python 0.6.0, Node.js 0.4.0, Go and Rust 0.6.0, and Kotlin, Swift and .NET 0.4.0 provide hub skill listing, installation, updates, removal, and history. Writes support optional operation waiting; retain the complete accepted response to resume after a polling failure without repeating the write.

    Hub-addressed skill operations affect the attached runtime group and every hub sharing it. Use separate runtime groups when hubs need different skills. Restricted tokens must cover every hub served by the group.

    MCP 0.2.0 consumes Node SDK 0.4.0 and adds thalovant_list_hub_skill_history, including in read-only mode. See Add a Skill to a Hub and the SDK guides for method names and examples.

    Python 0.5.16 and Node.js 0.3.16 start no new status read at or after the polling deadline. If a status read fails, both retain the accepted operation ID and the original sanitized API error so callers can resume polling without submitting another write. The polling deadline does not cancel an HTTP request already in flight. Python also rejects malformed skill-list rows instead of silently dropping them and corrects the shared CLI wait guidance.

    MCP 0.1.24 requires Node SDK 0.3.16 and uses its public hub-skill methods, preserving MCP cancellation checks and the existing 45-tool default catalog. See Add a Skill to a Hub for the available clients and recovery guidance.

    The follow-up releases are Python 0.5.14, Node.js 0.3.14, Go 0.5.4, Rust 0.5.2, Kotlin and .NET 0.3.3, Swift 0.3.2, embedded C v0.5.1, and MCP 0.1.22.

    • High-level SDKs reject duplicate active Ask request IDs and Query IDs within their client scope, preserving independent namespaces. Use fresh IDs for later operations too; delayed replies can outlive cancellation.
    • Node refuses malformed saved trust and serializes complete filesystem state transactions across processes. Browser state remains scoped to one page’s queue; independently active tabs need separate identities and namespaces.
    • Go and Rust also tighten saved-pin validation; Rust’s first-contact setter rejects conflicting replacements. Python, Node, Go, and Rust recognize equivalent hexadecimal pin encodings without treating letter case as a server-key change.
    • All high-level SDKs distinguish usable partial intent definitions from empty or error responses followed by silence. Fully answered empty descriptions remain valid. .NET retains successful engine manifests when another engine is denied or silent.
    • Go and Rust reject blank hub etags before sending; Kotlin rejects ratings outside 1–5. Retry examples require an explicit retained idempotency key. Runtime-group configuration replaces prior values and requires serialized writers because the API has no conditional-write token.
    • Embedded C rejects malformed object separators after a requested field instead of returning an early success. Its examples stop on builder and codec errors.
    • Credential-name redaction now covers nested identity and bootstrap metadata while explicit secret persistence remains available. Rust omits unstructured HTTP error bodies and reports a WSS peer close with its status code instead of an authentication timeout.
    • MCP consumes Node SDK 0.3.14; provisioning tests cover successful tool results and protected identity-file creation. Its policy guide now makes global-deny precedence explicit.

    See the current versions and the saved-keys guidance.

    Hub-addressed skill methods manage attachments on the hub’s runtime group; every hub sharing it is affected. It can start with no skills at all and gain them one at a time. Changes apply live in about 15 seconds without a restart.

    • In the app: Skills tab, Add skill, pick the skill and a version, confirm. The row shows install status until it settles; Update and Remove sit on each row.
    • API: GET and POST on /v1/hubs/{hub_id}/skills; PATCH and DELETE on the same path followed by /{skill}. Address it by id, not slug. Listing needs hubs:inspect; writes need hubs:write and a paid plan, return HTTP 202 with an operation_id to poll on /v1/operations/{operation_id}, and answer 409 (skill_version_already_installed) when already at that version or 404 (hub_without_runtime_group) without a runtime group. Errors are problem JSON with a root code.
    • Python SDK 0.5.15 adds list_hub_skills, install_hub_skill, update_hub_skill, and remove_hub_skill, plus the thalovant skills list|add|update|remove CLI subcommands. Node SDK 0.3.15 adds listHubSkills, installHubSkill, updateHubSkill, and removeHubSkill. wait polls the operation every 2 seconds for up to 120 seconds by default.
    • MCP 0.1.23 adds four matching tools, thalovant_list_hub_skills and the install, update, and remove counterparts; the default catalog grows to 45 tools.

    Go, Rust, Kotlin, Swift, and .NET do not have these calls yet. See Add a Skill to a Hub.

    SDK Feature Parity And Credential Security

    Section titled “SDK Feature Parity And Credential Security”

    The coordinated set is Python 0.5.12, Node.js 0.3.12, Go 0.5.2, Rust 0.5.1, Kotlin and .NET 0.3.2, Swift 0.3.1, embedded C v0.5.0, and MCP 0.1.21.

    • Shared runtime workflows now cover routed queries, conversations and event waits across the high-level SDKs. Streams use bounded queues where provided; Node uses direct callback subscriptions. Silent intent listings fall back to engine manifests; optional fallback discovery distinguishes unknown support from an empty result and provides a conservative language check.
    • Ask, Query, and event-wait budgets include connection and authenticated readiness, and the applicable sending and reply collection. A cancelled queued caller cannot close the active connection. Cleanup retains ownership until work stops; uncertain writes are never replayed automatically.
    • HTTP cleanup reports a refused or invalid disconnect response and retains responsibility for an unconfirmed remote session until cleanup is confirmed. A documented already-disconnected acknowledgment permits recovery when an earlier successful response was lost. The SDK retains cleanup responsibility, and MCP blocks later tools from reusing that identity in the same process.
    • API calls refuse redirects and URL userinfo. Authenticated calls and request bodies require HTTPS except explicit loopback development endpoints. The .NET patch requires migration from an arbitrary injected HttpClient for credential-bearing calls; see its guide.
    • Go 0.5.0 requires Go 1.26; Rust 0.5.0 requires Rust 1.88. Both retain existing request and inventory struct shapes through additive options and capability wrappers.
    • MCP adds routed Query, runtime intent inventory, and operation status tools, uses Node SDK 0.3.12, and binds configured credentials to their configured API origin. MCP request cancellation reaches supported runtime operations; cancelled queued tools never run later, and accepted work retains its identity through cleanup.
    • See Platform Limits for supported runtimes and operating systems.

    Transport tiers remain unchanged: Kotlin, Swift, and .NET use WSS; embedded C supplies protocol helpers with caller-owned transport. Keep each client’s saved keys during upgrades. Python replaces the additional best-effort readiness wait from 0.5.7 with a single strict connection budget. See the SDK compatibility table.

    Python Session And Intent Listing Follow-Up

    Section titled “Python Session And Intent Listing Follow-Up”

    Python 0.5.7 retains the trust-state and timeout-error fixes from 0.5.6. It adds a bounded readiness wait after connecting so later operations can reuse the session, and its default intent inventory falls back to engine manifests when the listing query receives no answer. See the Python SDK for timeout and fallback behavior.

    • Python 0.5.6 preserves timeout errors after HTTPS cleanup and reports malformed saved pins without overwriting trust state.
    • Node SDK 0.3.5 enforces MQTT TLS after endpoint normalization and keeps MQTT setup and HTTPS failure cleanup within the connection timeout. MCP 0.1.19 includes this SDK update.
    • .NET 0.2.1 publishes complete keys and pins so interrupted writes cannot poison the saved identity.
    • Swift 0.2.1 lets concurrent calls join one authenticated connection attempt. Embedded C v0.4.1 and Swift enforce the final authentication step.
    • Rust 0.4.8 shares session negotiation and its credential cache across WSS, HTTPS, and MQTT.

    Existing transport and platform support remains the same. Keep each client’s saved keys when upgrading.

    • All eight SDKs now open the same encrypted, authenticated session with a hub. Kotlin, Swift, and .NET remain WSS-only, and embedded C requires the application’s transport. The SDK compatibility table lists exact package versions.
    • Python, Node.js, Go, and Rust authenticate WSS, HTTPS, and MQTT sessions, keep their saved keys across reconnects, and keep their HTTPS session. An authentication failure never replaces a saved hub identity or falls back to an older transport.
    • MCP 0.1.18 uses Node SDK 0.3.4 for its hub runtime tools. Keep its saved keys between restarts and use different identities for concurrent MCP processes.
    • Upgrade older clients before connecting to a current hub; an older identity’s crypto_key no longer enables anything. See the language pages for storage requirements, embedded memory limits, and the Swift Linux WebSocket runtime requirement.
    • Updated the language guides and developer entry page for all eight current SDKs, including browser and platform restrictions.
    • Corrected the Python action and rich-response examples to use the published method names and response fields.
    • Clarified that MCP API authentication and the identity used to connect to a hub are separate setup steps.
    • Added connection troubleshooting for unsupported versions, changed server identities, and shared client identities. Clarified that Autoscaling capacity is selected on a hub, separately from shared runtime settings.
    • A connected client can now list every intent its hub answers, per language, with the sentences a person says to reach each one. The answer travels over the client’s own session, so no API token is involved.
    • The connection must be allowed to publish ovos.intent.list, and ovos.intent.describe as well when the SDK has to ask for the sentences separately. It asks the hub to return them with the listing, so a runtime that honors include_definitions never makes it send a describe at all, and that second type is not needed there. No shipping runtime honors it today, Thalovant’s included, so allow both types. A hub that refuses answers at once with a policy error naming the type, and the SDK falls back to intent names only when the hub allows the older engine manifests. Connections created for SDK clients and Thalovant Voice allow both types by default.
    • A hub that answers a query with an error means two different things by it. A failed listing raises the SDK’s runtime error carrying the hub’s error text, because a listing that failed is not an empty hub. A failed describe leaves that one intent without sentences and raises nothing: the hub does not know that registration.
    • Python SDK 0.4.36 ships client.intents(...), list_intents, describe_intent, ThalovantPolicyDeniedError, and the thalovant intents command. Node.js, Go, Rust, Kotlin, Swift, .NET, and the embedded C library now publish the same calls under their own spelling: @thalovant/sdk 0.2.39, thalovant-go-sdk v0.3.14, thalovant 0.3.1 on crates.io, com.thalovant:thalovant-sdk 0.1.8, thalovant-swift-sdk v0.1.9, Thalovant.Sdk 0.1.13, and thalovant-embedded-c v0.3.0. Those versions, and Python 0.4.40, are the first that report a failed listing as an error. Each SDK page has a working example.
    • See What Can My Hub Be Asked? and List What The Hub Can Be Asked.
    • Every SDK can now sign in through your browser: the SDK prints a short code, you approve the request at https://dash.thalovant.com/activate, and the SDK receives a scoped, revocable API token instead of handling your password. Requires Python 0.4.22, Node.js 0.2.25, Go v0.3.3, Rust v0.2.20, or Kotlin, Swift, and .NET 0.1.1.
    • Added the API Tokens page: create scoped, expiring tokens for scripts, CI, and AI agents, copy the one-time secret, watch last use, and revoke. Creating and approving tokens needs a paid workspace plan.
    • Every SDK also documents direct API token auth through its control-plane constructor. See Sign In Without A Password.
    • MCP server 0.1.9 recommends a scoped THALOVANT_API_TOKEN for AI and CI configs, and its config status tool reports the declared auth mode. See MCP Server.

    Unrestricted Source Scout Knowledge with Optional Age Protection

    Section titled “Unrestricted Source Scout Knowledge with Optional Age Protection”
    • Source Scout no longer limits adult hubs to a topic allowlist. It accepts any nonempty question as the final source-backed fallback after more specific skills have had a chance to answer.
    • Runtime owners can explicitly protect audiences under 13, 16, 18, or 21. The setting checks both questions and answers and fails closed when a protected classification cannot complete.
    • The unrestricted default does not invoke age classification. Protected and unrestricted responses use separate cache identities.
    • Source Scout preserves OVOS language, script, and region tags and is not limited to English and French.
    • See Skills and Configure Runtime for the owner workflow.
    • Hub creation and editing now offer Standard or Autoscaling capacity.
    • Team includes one Autoscaling hub with two warm workers and a maximum of eight. Enterprise capacity is contract-defined up to 32 workers per hub.
    • Billing reports autoscaling slot usage and each hub’s saved worker ceiling.
    • Existing hubs remain Standard. Autoscaling answers through installed skills; Persona and general LLM replies are not available in this profile.
    • See Create a Hub, Hubs, and Billing and Plans for the user workflow.
    • Thalovant Voice now reconnects automatically after a normal hub restart, a failed connection attempt, or a network ping timeout.
    • Every reconnect creates a fresh encrypted session and continues to check the saved hub identity.
    • The reconnect behavior is available on macOS, Windows, and Linux.
    • Existing paired clients can install the update without creating a new connection. If the app reports that the server identity changed, stop and confirm the change through support instead of bypassing the warning.
    • Go SDK v0.3.0 updates golang.org/x/net to its remediated release and therefore requires Go 1.25 or newer. It includes the v0.2.17 binary-frame allocation hardening.
    • Rust SDK v0.2.17 removes the vulnerable rustls-webpki 0.102 dependency path by using the operating system’s native TLS backend for MQTT. HTTPS and WSS remain on the fixed Rustls dependency line.
    • Added the Private Beta Guide covering consent expectations, the first useful path, privacy-safe measurement, support, withdrawal, account export and deletion, and the warning to use test payment details only.
    • Private-beta participation is measured using random IDs and aggregate milestones, without recording names, email addresses, prompts, replies, credentials, or payment details in those measurements.
    • Go SDK v0.2.16 is available as a public Go module. Clean consumers can install it through the public Go module proxy without GitHub credentials or private-module configuration.
    • Updated the Go SDK guide with the immutable verified release command.
    • Added privacy-safe setup milestones for aggregate onboarding and time-to-first-value measurement. Prompts, replies, memory content, email addresses, tokens, credentials, and secret material are excluded from activation metadata.
    • Account deletion now erases linked product telemetry, activation milestones, analytics summaries and exports, and identity-linked audit traces before removing the account.
    • Updated Analytics and Audit with the user-visible privacy and deletion behavior.
    • Added Status Stream guidance for versioned condition events, ordered sequence cursors, bounded replay, duplicate suppression, and snapshot recovery after an explicit cursor reset.
    • Clarified that the official SDKs do not yet wrap the control-plane status SSE endpoint.
    • A browser preview problem does not change hub visibility. Use your normal client connection while preview is unavailable.
    • Added SDK origins for browser origin requests, reviewer notifications, email handoff, and non-credentialed CORS behavior.
    • Updated SDK, endpoint, identity, and dashboard guidance so browser apps use reviewed origins while long-lived secrets stay server-side.
    • Simplified the docs home page so new readers see the smallest useful path first: learn the basics, build one setup, connect a client, or fix a visible problem.
    • Tightened first-read and high-friction pages so locked actions, limits, setup links, and first-heartbeat checks are easier to route.
    • Updated the docs style guide and page template to favor one clear promise, one clear first action, and fewer competing links.
    • Added Connect a Client for the current Connections flow.
    • Updated client guidance for one-time setup links, Thalovant Voice, Linux setup commands, and first-heartbeat checks.
    • Refreshed Quick Start, First Successful Setup, troubleshooting, limits, and security pages so setup links appear before manual file handling.
    • Added Manage Updates as the plain-language owner for skill updates, runtime updates, hub updates, and plan gates.
    • Refreshed Runtime, Skills, Hubs, Dashboard, Billing, and Known Limits so users can tell whether an update belongs to a skill package, runtime container target, hub container target, or plan check.
    • Updated plan-limit language so Billing remains the source of truth for exact workspace allowances.
    • Added the Analytics page for usage analytics, demand signals, geography, client posture, and hub/client detail filtering.
    • Updated Dashboard guidance for the current Fleet overview, Fleet snapshot, Client activity, attention, and update panels.
    • Added the Audit page for account trail, session history, visible actions, and support-safe history packets.
    • Clarified that paid Skill Store access is plan-reported rather than hardcoded in docs.
    • Refreshed Runtime guidance for primary and secondary languages, and Topology guidance for delayed status catch-up after broad service trouble.
    • Added the status page to help, limits, troubleshooting, support-request, and Discord setup guidance.
    • Updated support templates so readers capture whether the status page was checked before filing broad service issues.
    • Added the public Get Support page with support, bug report, and feature request templates.
    • Added Known Limits with a plan-first limit check.
    • Added Troubleshooting Index so readers can route from a visible symptom to the owner page.
    • Added public Discord support channels and welcome guidance.
    • Added support handoff language that warns readers not to share tokens, passwords, API keys, client secrets, connection files, private customer data, or sensitive screenshots.
    Open get support