What shipped

Pause all automations: one account switch stops every project's schedules, webhooks, app events and monitors.

The managed model list, prices, limits and reasoning levels come live from Platinum, so a model Platinum adds reaches Kortix without a release. Self-hosted and bring-your-own-key projects can add a Platinum key and call platinum/<model> directly.

Every project's models go through the gateway, and custom OpenAI-compatible endpoints are set up in the gateway as custom providers.

Every trigger keeps a list of its runs with status, error and end time. You can test-fire a trigger with a payload, replay a past run, and missed cron slots are bounded.

A project can be transferred to another organization or account. (#9918)

Every account is on Free or Credits, with top-ups on either. Balances and usage read in credits everywhere; prices you pay stay in your currency. Raising your plan applies at once; lowering it takes effect at the next renewal, with a preview before you confirm.

A tool is one module that OpenCode and pi both run. Declare a project's own tools under tools: in kortix.yaml, and limit which agents see them with agents.<name>.tools.

A folder with thousands of files loads in pages with Load more, and Find a file now searches file contents as well as names.

Kortix Capture records only the apps and websites you include: an organization policy plus a per-computer list.

SSO, SCIM, roles and groups, audit and branding come with an Enterprise license or a self-serve demo. Trials are gone. Admins can now manage billing.

A session shows which model answered and what the answer cost.

A message sent with Enter while the agent works reaches the running turn at its next step, and the turn does not stop. The message waits above the composer as "Read at next step". Cmd/Ctrl+Enter still queues a message for after the turn, and a queued message has a "Stop and send" action. The CLI has kortix sessions chat --steer.

Two-factor step-up opens full screen, and the MCP connect dialog uses a split layout with the details beside the form.

The pi harness is on pi 1.0. It brings compaction and slash commands, and pi now runs only inside the sandbox.

The queue above the composer updates from the session stream instead of a once-a-second poll.

Sessions carry writable labels and metadata across the API, SDK, CLI, MCP and web, and the session list filters by label.

One account-level MCP server at /v1/mcp, bound to your token like the CLI. It exposes sandbox shell and files, skills, and the session list; long commands run as jobs, and connected apps can be listed and revoked. kortix mcp runs the whole CLI as an MCP server, and a Connect MCP menu sets it up.

Each physical computer appears once, even after you re-pair it. Computer Use runs inside the Kortix desktop app, and it asks for every macOS permission right after you connect. Pairings with no hardware id that stay silent for 30 days are removed.

There is no feature flag to turn on: connect Teams from the project's Connectors → Channels page. A tenant admin consents once, or the project brings its own bot. A project that connected Teams while it was a flag keeps its install. @kortix/sdk keeps teams as a deprecated flag key that always reports enabled. (#8601, #8603)

An agent that holds a permission can do the work end to end. kortix_permissions: all, "*", and any list that contains "*" mean the same thing. With all, an agent can also manage project members and delete the project. Creating credentials stays with people.

Models you reach through your own API keys, keys shared with you, project keys, and ChatGPT subscriptions are available in Teams, Slack and the CLI, not only the web picker.

Every entry shows a readable title instead of a raw route, in all nine languages. Every API route and event now has a label, and kortix audit ls prints the same titles in the terminal.

kortix tui opens a full terminal client: sidebar with accounts, projects and grouped sessions; session transcript with tool cards and interactive prompts; a composer with a command palette and model, effort and agent pickers; Files, Review, Apps and Customize screens; an embedded terminal; and opencode attach mode. It installs its own binary on first run, so the CLI stays small.

An agent session now acts as the agent, on behalf of the person who started it, and every audit event records both. The kortix_cli permission scope is now kortix_permissions.

/projects lists your projects and opens them in place.

Bring several keys for one provider, keep them private or share them with named members, and let each session hold its own key. Sessions fail over to the next key and report the earliest retry time when a pool is exhausted. Gemini and ChatGPT keys pool too, and pooled keys are managed in Models. Pool access is bound to the session owner, and a pool is checked against the model you actually picked.

Cmd+P prints the full session as a clean document — every message, not one clipped screen of the app.

A connection now carries the accounts you may run it as, and the account is chosen when the connector is called rather than pinned to the whole session. The connector catalog, the SDK and the CLI all report the available accounts and the pinned default, and connectors/describe shows accounts instead of only tool counts.

Owners and admins choose which model providers and which models a project may use, from one model management view that also holds provider links. Kortix managed models sit beside your own providers in the same list, a ChatGPT subscription shows its access beside its credentials, and the picker distinguishes "not shown" from "blocked" so a member sees why a model is unavailable.

It is no longer behind a feature flag — the routes, registry, contract, web surfaces, CLI, and docs all ship it by default.

Every supported language now has complete translations across settings, onboarding, project home and sidebar, sessions, password recovery, sign-in, and workspace administration. Serbian is a new locale. 241 entries that rendered as placeholders now show real text.

Desktop asks which Kortix instance to use on first launch.

Headless auth: multi-factor enrolment, enterprise SSO, and profile updates are available through the API and the SDK (PATCH /v1/auth/user, KortixSession.subscribe as the replacement for onAuthStateChange).

Kortix Apps: one identity guard for every App (createKortixAppGuard, groups always populated), and an embedded App can complete its own sign-in (cookieSameSite).

Session brief: hover a session to see its summary.

Apps is now a stable feature — it moved out of experimental status and sits in the sidebar under Customize. Apps open instantly (no more loading flash), show their desktop layout on the preview card instead of mobile, and get their own IAM permissions and per-team scoping. Non-public Apps are now usable and honest about who can access them; self-host installs can serve Apps even though they can't publish to kortix.com.

Signup confirmations, magic links, invites and alerts all flow through the same EMAIL_URL transport with the same sender identity and templates — self-hosted installs configure email once. Supabase auth mail now goes through the same path instead of GoTrue's own SMTP.

Invite-time project grants — inviting someone to a project now grants both the account role and project access in one step, instead of two separate actions.

Connecting an MCP server that requires OAuth 2.1 now works end-to-end from the UI or via kortix connectors authorize — discovery, dynamic client registration and token exchange included.

Settings unified into one tabbed panel, and the Billing pane was rebuilt with fewer boxes and a single credits card.

Act-as for support — platform admins can open a customer account for up to one hour, with a visible banner and full auditing. Anything that would outlive the hour — tokens, memberships, invites, SSO providers, public shares, tunnels, agent scope changes — is refused during the session.

Your terminal is now a first-class way to work with an agent: kortix connect opens a session picker and attaches a full terminal UI to any running session, and can create a session and connect in one step. Bare kortix shows the landing screen again.

Per-account entitlement overrides — operators grant or extend individual entitlements per account, each with an optional expiry, from a new admin override console. Expired overrides stop applying on their own.

Feature flags: one gating primitive across API, web, and CLI. Disabled features answer with a clear feature_disabled error everywhere, and each project gets a dedicated Feature flags section under Customize.

One plan catalog — plans now resolve through a single catalog and resolver across API, SDK and web. The duplicate frontend tier catalogs and the "· legacy" plan label are gone.

Decide exactly which secrets each agent session can use. Policies are managed from the web app and CLI, secrets reach sandboxes through an audited HTTPS broker with session-scoped handles, revoked secrets disappear from running agents, and LLM, connector, git, and subscription credentials are isolated from each other. A new kortix audit CLI command reads the account audit trail.

Imported legacy Suna chats are now first-class: migrated sessions show up in the session list with a restore state (instead of a misleading "Done"), and opening one restores its full conversation history into the session. Files from every imported chat live in the project repo under legacy/. (#6235, #6241, #6251)

One-shot approval links: approve or reject an agent's pending request straight from the notification link, without opening the app.

One connector model across web, CLI, SDK, and API: consistent Connector and Connection terminology, a single data plane in @kortix/sdk, and connector credentials that bind to project secrets. The connector catalogue now pages through the full ~2,700-app list instead of stopping at 192.

Admin: an activity-analytics dashboard, a projects console, clearer tier labels, and admin-issued trials with per-account entitlement overrides. (#6244, #6249, #6250)