Changelog

This release strengthens account controls, billing enforcement, Daytona reliability, and model choice while keeping the Machine experience familiar.

Account and billing controls

• Administrators can ban and unban account owners, and bans now stop already-issued human sessions immediately.
• A new admin view lists accounts that still hold credits but do not currently have an active Stripe or mobile subscription.
• Wallet credits no longer bypass the paid-seat requirement: a per-seat account needs both an active subscription and a funded wallet.

Models and providers

• Added model support and provider branding for Fable, K3, and Thinking Machines: Inkling, including the Thinking Machines favicon in the model picker.
• Improved fallback routing, reasoning settings, tool use, blank-response handling, usage accounting, and billing reconciliation across managed models.

Daytona and workspace reliability

• Daytona remains the primary cloud sandbox path, with safer retries, backup and recovery controls, persistent-volume checks, and clearer fleet diagnostics.
• Session previews can use signed direct-port URLs, while file uploads and archive extraction now stay inside the active SDK runtime and reject unsafe archive paths.
• Added new project customization, connector discovery, WhatsApp, SSO enforcement, and sandbox-provider coverage capabilities without replacing Machine's existing tools.

Experience

• Machine branding, themes, wallpapers, legacy dashboard tools, and the current session experience are preserved.
• The changelog is now served from this clean local customer-friendly source with no GitHub-link repair or remote release-history dependency.

This release makes model responses more reliable, errors easier to understand, security stronger, and sandbox development smoother.

AI model reliability

• Requests now use the correct endpoints and settings for OpenAI, Anthropic, and Amazon Bedrock, including reasoning models and tool use.
• Amazon Bedrock can now be connected directly with your own credentials, with the region configured securely for each project.
• Streaming requests stop cleanly when canceled, surface mid-response failures instead of hanging, and use sensible limits and deadlines.
• Provider differences are handled through one translation layer, improving consistency across supported models.
• Usage, caching costs, and project budget tracking are now more accurate.
• A new capability matrix clearly shows which features each model and provider supports.

Security

• Outbound network requests now use stronger DNS-aware protection against server-side request forgery.
• Microsoft Teams connector tokens, session deletion metadata, shared previews, Slack file access, MFA settings, and AgentMail webhooks all received additional safeguards.
• Infrastructure now enforces HTTPS-only traffic and more durable web application firewall protections.

Sandboxes and CLI

• The CLI can validate a sandbox Dockerfile before you push and build it locally with sandboxes build --local.
• Custom files in /workspace are preserved, Python environments are isolated, and terminal sessions recover more reliably across providers.
• Stopped sandboxes automatically resume when you return to an active OpenCode session.

Web experience

• The session panel has been rebuilt with Easy and Advanced modes, improved file viewers, and cleaner tool displays.
• Setup and startup messages are clearer, including the new “Kortix Session is starting” message.
• Automatic sandbox selection no longer exposes the underlying provider to project members.

Improved release version reporting across the gateway infrastructure and completed the production gateway TLS recovery. Standby and public gateway endpoints now report the same promoted version, making deployments easier to verify and support. No major interface changes are included in this release.

Managed model availability now refreshes automatically when a warm sandbox is reused. OpenCode restarts only when the live model catalog has actually changed, reducing unnecessary interruptions. This release also improves gateway routing in staging and was verified end to end with fresh sandboxes.

Self-host hardening wave from the production-readiness audit, an experimental local-docker sandbox provider, and an auth refresh fix.

New

• Experimental local-docker sandbox provider for self-host — run agent sandboxes as plain Docker containers on the same machine as your Kortix instance, with no cloud sandbox account. All sandbox-facing URLs resolve over the Docker network. Listed last in the provider picker and not recommended for production: it builds sandbox images locally and is noticeably slower than Daytona or Platinum.
• Moving development, staging, and production image tags — self-host instances can now track a channel-style tag (kortix self-host init --tag dev|staging|prod); CI re-tags the deployed build by digest, no rebuild.
• Smoother SSO and SCIM setup — mint the SCIM token and paste it into your IdP on one page, live SSO verification with a resume story, complete Directory Sync and Google guide screenshots, and a visible "Use single sign-on (SSO)" entry on the sign-in page.

Improved

• Self-host updater — resilient update runs with visible outcomes (kortix self-host status now shows the last update result), rotated container logs, and per-service memory limits so one service can't starve the box.
• Self-host EC2 (Terraform) — the data volume now survives instance replacement (AZ pinned to the subnet, not the instance), reboot-surviving bootstrap, containerd relocated to the data volume, and CloudWatch status/disk/memory alarms.
• Zero-downtime migration policy — every new database migration is linted by squawk plus deterministic mixed-version and enum-value guards in CI, with a rewritten migrations runbook.

Fixed

• Silent auth refresh — sessions renew in the background; an expired token no longer leaves a dead, blank page.
• Git PAT import — a saved managed-git personal access token is now recognized as a connected GitHub account, so repo import works without reconnecting.
• SCIM Tenant URL is now correct on same-origin and self-hosted deployments.
• Removed the legacy SANDBOX_IMAGE configuration surface from self-host.
• Scoped the ECS deploy role's describe/list IAM actions to Kortix ARNs.

New

• Unified sign-in — login and registration are now one email-first flow: enter your email and Kortix routes you to sign-in, sign-up, or your company's SSO automatically (with closed-signup and enforce-SSO support).
• SSO out of the box on self-host — SAML is enabled by default, each instance generates its own SAML signing key at init, and SSO and SCIM setup is fully documented.
• Identity setup wizard overhaul — reworked Entra wizard, SAML-before-SCIM ordering guidance, a provisioning health panel, an enforce-SSO toggle with clear domain consequences, and illustrated guides for all four SSO and SCIM flows.
• Admin-controlled account creation on self-host — creating additional accounts is now restricted to the server admin by default (signups, teams, and SSO provisioning are unaffected), and the interface hides account creation when restricted.
• Simpler self-host CLI — one env command, an uninstall command, and a friendlier init: a missing sandbox key warns instead of refusing to boot.
• Enterprise license availability is now exposed on account state (API + SDK).

Fixed

• Managed model provider now follows billing configuration by default, fixing managed models being unavailable on some deployments.
• Self-host updater no longer fails on Docker-in-Docker mounts; the provider menu is always visible; configure records the admin email.
• Non-admins no longer see an incorrect Git-status error.

Under the hood

• Production deploys are now hard-gated end to end: the release only publishes after the API and gateway deploys verify the live version.
• Demo requests notify the team directly with lead-domain classification, and new signups sync to the contact list that powers onboarding emails.
• Repo cleanup: self-host layout consolidated, stale roots removed, self-host docs moved under Guides.

Self-host hardening — everything live-verified

• Agent sessions work everywhere: fixed the model service URL handed to cloud sandboxes and the in-API gateway path shape — bring-your-own-key model keys now carry real agent turns on local machines (Cloudflare tunnel) and VPS (domain) alike, proven end-to-end.
• Guided setup, VPS-first: kortix self-host init walks domain/reachability → admin email → deployment shape → sandbox provider (Daytona/E2B/Platinum) → optional connectors → update schedule. Help text cut to a page. Auto-update on by default.
• GitHub connection hardening: personal-account installs route correctly, torn configs are detected, the Git settings tab never renders blank, and 'New project' takes you to Git settings when GitHub isn't connected yet.
• CLI against your self-host: kortix login opens your deployment's dashboard and the full login → projects → ship flow is verified.
• kortix-selfhost/: one-README distribution with an optional thin Terraform for AWS/EC2 — durable data volume, automatic EBS-snapshot backups (configurable cadence, keeps N), DNS via Route53 or your own provider.

Self-hosting, rebuilt

• One generic Docker Compose self-host that runs the full Kortix platform on any VPS/server — kortix self-host init + start, VPS-first with a persistent domain (Caddy + automatic TLS), plus Cloudflare-tunnel and local modes for evaluation.

• In-app GitHub setup — create an org-owned GitHub App from Settings → Git (manifest flow), paste an existing App, or use a scoped access token. No CLI gymnastics, no PATs required.

• Self-host feature flags — single-account mode, marketing site off by default, enterprise license unlock, billing/connectors gracefully hidden when unconfigured.

• Operations built in — nightly zero-downtime rolling updates on the curated stable channel (promoted via the new Promote Self-Host Stable workflow), kortix self-host secrets management, run-any-version + local-images modes, required-secret enforcement at init.

• Kortix-managed models are cloud-only — self-host deployments use your own model keys (bring-your-own-key); the managed catalog is gated behind an explicit flag.

• Reliability — SSE turn-stream no longer leaks connections on retry (fixes tab-wide request starvation); stale sessions self-heal instead of getting stuck on the auth screen.

• New self-host end-to-end test suite (fast CLI-artifact tier + opt-in live tier) wired into CI.

Fixed

• Opening an idle-stopped session now wakes it on its own instead of getting stuck on "OpenCode failed to load / sandbox not ready." When a real user hits a stopped-but-resumable box, the runtime resumes in place, and the session's status flips to running without a manual refresh.
• Invitation listing and acceptance no longer error — a database column the code relied on was missing and is now added.
• Sessions keep their sandbox identity through recovery and reprovision cleanly after a daemon boot error.
• Quieter, more reliable interface: the transient "runtime still starting" state is no longer reported as an error, and a couple of edge-case crashes (malformed links, a non-string command template) are guarded.

New

• Executor connection profiles — group a connector's credentials under a named profile.

Fixed

• Opening a session whose sandbox had gone idle no longer gets stuck on "OpenCode failed to load / sandbox not ready." The runtime now wakes on its own when you open the session — the same recovery a manual refresh used to do — so idle sessions just come back.
• A session's status now flips to "running" in the sidebar as soon as it connects, instead of staying "stopped" until you refresh the page.

Fixed

• Opening or switching sessions no longer flashes a blank screen. A brief "runtime still starting" moment during a switch is now treated as a loading state, not an error, so the session just renders in place.
• A session whose sandbox had gone idle no longer gets stuck on "open a new session." It now resumes on its own, with an in-place Restart if it can't wake automatically.
• Cleaned up the marketing site: removed dead Compare links from the footer, dropped Blog from the nav, and fixed the CLI footer link.

Improved

• The deploy maintenance banner is clearer and on-brand, and is treated as a critical rollout signal.

Fixed

• Switching between sessions no longer flashes a "Something went wrong" screen. A brief "runtime still starting" state during a session switch now shows a short loader and recovers on its own instead of surfacing as an error.
• The review inbox (sidebar and Review Center) keeps loading even when one of its sources is temporarily unavailable — it now degrades gracefully instead of failing the whole panel.
• Session file uploads are recoverable again after an interruption.
• PDF previews now open at 100% zoom instead of 50%.
• Sign-in polish on mobile: the mark is pinned top-left, gutters are wider, and the tagline is refreshed.

New and improved

• Signing in now defaults to a one-time email code, with password kept as a secondary option.
• Projects still on the older manifest now show a clear v1 → v2 upgrade prompt in the sidebar.
• Maintenance mode: admins can bypass a full lockdown through a signed session, and deploys now raise a heads-up banner while a rollout is in progress and clear it automatically once the API is healthy.

Session uploads are now more reliable on slower connections. Uploads are no longer cut off by the previous 15-second limit, and a failed send restores the full message and its attachments so nothing is lost. This release also safely migrates older personal connector credentials and restores required session profile data.

Promoted a fully tested release candidate to production. This update includes safer sandbox recovery, more reliable deployment health reporting, authentication improvements, chat input fixes, and better handling of each project’s default Slack agent and model.

Slack threads can now be permanently linked to a session, making approval and follow-up conversations easier to continue in one place. This enables workflows where a user can approve a request directly from the Slack thread and the agent can continue automatically.

This release fixes a timing bug that could make an agent miss the very first message of a session, tightens single sign-on for teams, makes gateway errors say what actually went wrong, and hardens how OAuth tokens are stored.

Fixed

• Agents now reliably reply to your first message. On a fast startup, the agent could fire your opening prompt before it had finished subscribing to its own event stream — so a quick first turn finished in that gap and the reply was lost (most visible as a silent first message in Slack). The agent now subscribes first, reconciles anything it missed on connect, and delivers each turn's end exactly once.
• Clearer gateway errors instead of a generic failure. When an upstream model provider failed mid-response (for example, an overloaded or request-too-large error on an otherwise-started stream), the gateway used to bury it as a generic "empty completion" and retry the same failing provider until it gave up. It now surfaces the real upstream error and message, drops the failed provider immediately, and fails over to another one when available.
• SSO group-to-role sync now works for SAML. SAML providers weren't registered with a group-claim mapping, so the group attribute never reached the token and group-driven role assignment silently did nothing (login still worked). Providers now register with the correct mapping, and the SSO setup card documents the common identity-provider gotchas.
• SCIM group membership applies to pending invites. A user provisioned via SCIM but not yet signed in was silently dropped from pushed groups. Their group is now recorded on the invite and applied automatically when they accept, matching how project access already works.

Improved

• Sandbox templates show which provider they use. Each template card and recent build now carries a small provider chip (Daytona, Platinum, Managed), and the templates section is tidier and less cluttered.
• CLI secrets match the web app. kortix secrets set --identifier KEY=VALUE lets you store more than one value under the same key from the terminal, and kortix secrets ls now lists by identifier and flags any missing required keys — bringing the CLI in line with the web Add-secret experience.
• CLI token context shows your environment grant. kortix token / whoami --token-only now include the env part of an agent grant (not just connectors and CLI access), and a bound default project points you at kortix projects use to switch.

Under the hood

• OAuth server access and refresh tokens are now stored with peppered scrypt, matching every other credential (previously plain SHA-256). Existing tokens keep working until they expire.
• All OpenRouter usage now attributes to one canonical app (www.kortix.com) instead of splitting across per-environment entries.
• Removed an unused internal session-LLM route that no client called.
• Trimmed frontend build spend by skipping builds that don't touch the frontend and gating preview builds.
• Kortix is open and source-available.

New

• Marketplace imports. Agents, commands and bundles install into a project in one click. The detail view now shows what a listing actually contains — bundle contents, capability badges, type-aware copy — before you add it.
• Groups and custom roles on every plan. Previously limited by tier; now available to all accounts.
• Answer permission prompts from the CLI. Sessions that pause for approval can be resolved without leaving the terminal.
• One-click Slack connect via kortix channels connect — no manual app setup.
• Review center approvals. Approve and deny executor requests for real, with change descriptions rendered as markdown.
• OAuth1 connectors for OpenAPI and HTTP.
• Always-bound project CLI. login binds a default project; unbound commands recover interactively instead of failing.

Improved

• kortix.toml is now kortix.yaml (TOML stays supported as v1 legacy), with format-aware manifest errors and agent-scope/trigger-path parity.
• Destructive actions are confirm-gated: deleting secrets, revoking gateway keys, deleting sandbox templates and sessions, archiving projects.
• Loading states unified across the app; onboarding moves Skip into the footer per step.
• Upgrades are surfaced with an accent card and a Recommended badge.
• A complete IAM administrator's guide: SSO/SAML, SCIM, roles, groups, custom roles, agents, audit.

Fixed

• Sessions on projects pinned to the Platinum sandbox provider could not start. Production's sandbox_provider type was missing the platinum value, so every session create failed at the database. The value is now added; a sandbox that fails to start also raises properly so provisioning retries.
• Retry build / Fix with agent works again, snapshot quota cleanup can fire, and the prewarm cache is bounded with an alarm when cleanup falls behind.
• Permission leaks closed. Project detail sections are filtered by read capability, previously ungated project endpoints now check their capability leaf, member management gates on the leaf rather than a broad write floor, and viewers no longer see error toasts for surfaces they cannot read. Read-only users get a degraded view instead of a broken one, and the floor member role can fire triggers again.
• Service-account bearer tokens are accepted wherever user tokens are.
• Unknown CLI commands now error with a suggestion instead of silently scaffolding a project named after the typo.
• The model picker updates immediately after connecting a provider, and setup links render as clean CTA chips rather than raw token URLs.
• Resolved high-severity CodeQL findings (ReDoS, temp-file handling, TOCTOU, CLI opener).
• Rename dialogs no longer close mid-save; sessions and projects show honest error, empty and retry states.

Fixed

• Connecting an LLM provider with "Only me" access made the key invisible to the model gateway — sessions failed with "No upstream configured" while the provider still looked connected, and flipping an existing key to "Only me" silently left the shared key active for every member. Provider API keys are now always project-wide: the per-user option is gone from the connect flow and the API rejects per-user provider keys outright.
• The marketplace now paginates and virtualizes its listings, and installs no longer fail against a 25-second timeout.
• The detach-role dialog no longer shows a raw translation key and now spaces the role name correctly.
• Removed a distracting fade animation on the sidebar toggle.

New

• File and secret access can now be restricted per role: file and secret reads moved to the editor tier, and new groups default to the member grant.
• A warning now appears when a group's built-in grant overrides its assigned custom role.
• The New Project modal has an account picker, so you can choose which workspace a new project lands in.

Improved

• A smoother session-starting loader.
• A full accuracy pass over the docs (SDK, CLI, reference, and concepts) against the current code.

New

• Marketplace is on by default. Every project can now browse and install marketplace skills without a feature flag. Kortix Meet, Kortix Computer, and People Search are opt-in installs rather than part of the default set.
• People Search. A new starter tool that searches LinkedIn profiles (backed by Apify), runs to completion without timeouts, and is billed per call.
• Expanded skill library. A much larger set of default skills ships with every new project, and the auto-created "My First Project" now gets the full starter pack.
• SCIM provisioning that just works. Error-free user provisioning from your IdP: invited users arrive active, PUT updates are supported, email lookups are dedup-safe, and Azure AD connector setup gets /ResourceTypes + /Schemas discovery. The SCIM setup dialog now shows the paste-ready absolute base URL.
• SSO group auto-provisioning. An opt-in toggle creates groups (and their mappings) automatically from IdP claims on login, so directory structure flows into Kortix without manual setup. SSO and SCIM settings cards got status pills and visual group mappings.
• Upgrades section. Projects have an Upgrades registry with a one-off prompt runner, so platform-side improvements (like a baseline refresh) can be applied to existing projects on demand.
• Files is a standalone page with Google Drive-style colored folder tiles, out of the Customize overlay. Customize itself moves to a master-detail sidebar for agents, skills, and commands.
• Warm prebake on push. Sandbox images warm when a commit lands — for every provider a session can use — so sessions on recently-active projects boot faster.
• CLI: attach to a session. kortix can now attach directly to a running session's agent from the terminal.
• Per-account concurrent-session limits. Accounts can carry a custom concurrent-session override, and hitting the limit now explains exactly what happened.
• SDKs on npm. @kortix/sdk and @kortix/llm-catalog now publish to npm with every release, in lockstep with the platform version, joining @kortix/executor-sdk.

Improved

• Sandboxes no longer idle for hours. An observe-idle reaper with 15-minute/5-minute TTLs, a busy probe, and a provider backstop stop stopped-but-billing dead time.
• Agents automatically resume work when a turn is killed by a transient model-provider error, instead of stopping silently.
• The AI model gateway no longer forwards empty completions: it retries the same model once, then fails over to the next candidate. Upstream provider errors now surface in the stream instead of hanging it.
• The full member directory is visible to all account members (sensitive columns stay manager-only), and member counts reflect what the viewer can see. "Departments" are now "groups" throughout.
• The PDF viewer opens at a comfortable zoom with the sidebar closed, and presentation viewers drop redundant download buttons.

Fixed

• Change requests can no longer be empty. An agent that committed but never pushed used to produce a silent "No changes detected" change request; the push step is now enforced and empty CRs are rejected at open time.
• Session lifecycle races. Starting a brand-new session no longer trips over its own creation (the create-vs-start race), deleting a session mid-provision can no longer resurrect it, the first prompt of a new session is no longer dropped while the agent restarts, a session page open on a stopped sandbox no longer hammers it with requests, and the create-first flow no longer bounces back to the project index.
• The project-home composer keeps its text while navigating into the new session, and the sidebar flyout stays open while one of its menus is open.
• Legacy daytona provider names are normalized at session create, so older projects keep working after the provider rename.
• Suna migration pushes are now idempotent across pods and strip oversized blobs instead of failing.
• Snapshot cache keys are scoped to in-sandbox inputs, so unrelated source changes no longer invalidate sandbox snapshots.
• AgentMail inbox limits are handled gracefully instead of erroring the channel.
• API and gateway origin load balancers only accept traffic from Cloudflare, closing a WAF-bypass path.
• Gateway request logs strip NUL bytes before persisting, fixing a recurring database write error.

Under the hood

• CI hardening: staging keeps its VERSION in sync on release, a duplicate migration was deduped before it could break deploys, staging QA runs behind Vercel SSO with a bypass token, the direct prod fix workflow is retired, and dependency/action versions are bumped across the board.

Added flexible concurrent-session limits for individual accounts, allowing approved accounts to use a custom limit instead of the standard plan limit. This release also closes a serious lifecycle issue where a session deleted during startup could return and continue consuming capacity. Deleted or archived sessions now stay deleted throughout provisioning and recovery.

Fixed a session page issue that could repeatedly reconnect to a stopped sandbox and flood the browser with failed requests. Stopped sessions now use a slower, time-limited recovery process and clearly become unavailable if they cannot restart. Internal system folders are also no longer opened as regular files.

Agent sessions now automatically resume a turn killed by a transient provider failure (e.g. a model host stall ending in "Upstream idle timeout exceeded", connection resets, 5xx after retries) instead of surfacing a dead error turn. Root sessions only, max 3 resumes per 15 minutes with backoff, never for user aborts or auth/credit errors, kill switch KORTIX_TURN_AUTO_RESUME=0. Completes the v0.9.94 GLM routing fix.

Fixes the production "Upstream idle timeout exceeded" turn failures on GLM 5.2.

Managed glm-5.2 requests now carry OpenRouter provider routing preferences (order: [z-ai], fallbacks allowed) so they land on Z.AI's first-party endpoint (99.9% uptime, native fp8) instead of being load-balanced across ~20 hosts including low-uptime fp4 requantizations that stall mid-generation until OpenRouter kills the stream. The AI model gateway now detects in-stream upstream error frames (a 200 stream carrying {"error": ...}) and settles the request as upstream_stream_error with a warn log, instead of tracing a dead turn as a success — this failure class is now visible and alertable. Pre-content error frames keep flowing into the existing empty-completion retry/failover path (now regression-tested).

Fixed

• The AI model gateway no longer returns a blank, empty reply when a model provider silently produces nothing (a rare but real upstream failure mode). It now retries the same provider a few times, then fails over to another configured provider if one is available, before ever giving up — so a transient provider hiccup resolves invisibly instead of showing up as an empty response.
• The gateway strips stray NUL bytes from request/response logs before saving them, avoiding an occasional database error that could drop a log entry.
• Fixed a case where the first message of a new session could fail right after an environment restart, instead of waiting for the runtime to come back up.
• Made the internal migration step idempotent so it no longer depends on which pod happens to run it.
• Narrowed an account-membership repair path to be safer and more precise.

Improved

• Platform admins get read-only access to the project access gate for support/investigation, without full write access.
• Projects can now override which sandbox provider they use on a per-project basis.
• Slack identity verification is now enabled on staging, matching production.
• Handle AgentMail inbox-limit errors gracefully instead of surfacing a raw failure.

New

• Per-project sandbox provider override — pin a project to a specific sandbox provider (e.g. Platinum) from Customize → Settings, instead of always following the platform's weighted default.

Fixed

• Sandboxes could fail on literally the first message in a silent retry loop, caused by a broken dependency bundle baked into the sandbox image. Sandbox image builds now verify the bundle actually works before shipping.
• A new session's first prompt could be silently dropped right after sandbox startup, requiring a resend. The app now waits for the sandbox to finish restarting before sending the prompt.
• Fixed a Postgres error that could interrupt request logging when an LLM request or response contained certain binary characters.
• Fixed a migration bug that could strand a retry in a failed state instead of resuming cleanly.
• Fixed an edge case in account membership repair.
• Improved error handling when an AgentMail inbox hits its limit.

Under the hood

• Restored the full staging release-verification pipeline (Vercel authentication bypass) after a temporary gate exclusion.
• Removed the manual prod-fix workflow — all production changes now go through the standard promotion flow.

Fixed a production logging issue that could occur when model request or response traces contained unsupported characters. Gateway logs are now cleaned before being saved, preventing recurring database errors without affecting customer requests.

Fixed

• The first message in a new session now runs reliably. Previously the very first prompt in a brand-new project could silently do nothing, leaving you to send it again. A new session briefly restarts the agent runtime to load its configuration, and the first message was being sent into that restart window and dropped. The first message now waits for the runtime to be ready before it's sent, so it lands on the first try.

Improved

• Refreshed marketing site: a new Company-OS landing page with a Web / Slack / Teams / Mobile / CLI / SDK surface switcher and an interactive "your company, as files" explorer, a revamped enterprise hero, and a single "Request demo" flow across the site.
• New blog: rebuilt as data-driven React pages (replacing MDX) with branded post covers, plus comparison write-ups (Claude Cowork; OpenClaw + Hermes; ChatGPT / Claude / Grok) covering use-your-own-model cost and shared-vs-siloed work.
• The mobile app download preview now shows real app screenshots instead of a placeholder mockup.
• Cleaned up page titles and metadata so the title bar no longer repeats "Kortix".

Fixed

• Default-agent sessions now see their connectors. Sessions running as the default agent were getting an empty connector grant, which hid shared Slack channel and computer connectors — they now resolve correctly.
• Install-based connectors (Slack channel, computer) no longer show "connector not found" in the dashboard connector settings; they fall back to the live connector record.
• The Agent Computer Tunnel is now a regular connector: a connected machine shows up as a connector automatically, without needing an experimental flag.

New

• Guided project onboarding — new projects now open into a full-screen, step-by-step setup that walks you through connecting your tools and getting to your first run.
• One /kortix Slack panel — a single Slack command opens a unified panel with a real model picker and per-project default models.
• Desktop auto-update — the desktop app now updates itself, with a steadier always-on-top window.

Fixed

• Dead show tool cards no longer render a confusing "File not found" card — they're hidden when the artifact is gone.
• Stuck tool results now resolve themselves when a run finishes, instead of needing a page refresh.
• The in-sandbox terminal correctly replays your prompt again.
• AgentMail inbox-limit errors are handled gracefully instead of failing hard.
• Tighter, safer account-membership repair.

Under the hood

• Staging runs the full release gate behind Vercel SSO with the Slack identity gate enabled, and releases now go through promote only (the direct prod-fix path was removed).

Fixes

• Deactivate session agent-lock (KORTIX_ENFORCE_SESSION_AGENT_LOCK, default off): no more AGENT_SWITCH_REQUIRES_NEW_SESSION 409, in-session agent switching works, and the first prompt of a new session no longer fails. Agent picker unlocked in the interface.
• Send-retry: any sandbox 503 now rides the full boot/wake window (~29s) so a prompt to a waking box lands instead of reverting a message that actually ran.
• deploy-prod self-heal: assert the Argo app tracks 'prod' and repoint a stranded break-glass rollback before the rollout wait.
• Drata IaC CRITICAL fixed (scoped staging deploy secretsmanager perms); opt-in RELEASE_FAST_TRACK release lane.

Fixes

• Stop the false AGENT_SWITCH_REQUIRES_NEW_SESSION 409 that blocked new sessions on the second message. The proxy now treats the default agent sentinel as non-binding and only blocks a genuine switch between two distinct concrete agents; for default sessions the echoed agent is stripped so OpenCode runs its booted default_agent.
• Agent picker: clearer hover tooltip explaining a session's agent is fixed at start (start a new session to switch); switcher behavior unchanged.
• Includes billing duplicate-suppression and Platinum snapshot upload fixes already on main.

Promotes the staged Slack identity and session access hardening plus the fresh-account /accounts/me bootstrap repair. Includes the live staging candidate at 79d43a7f with staging API health verified before production promotion.

Fixed project creation for newly registered customers whose account membership needed repair during setup. The normal access checks remain in place, and the fix was verified in staging before release.

Promotes the Slack identity gate and access/authentication hardening with SLACK_REQUIRE_USER_IDENTITY enabled, plus the project-session agent binding fixes that prevent invalid agent switches and preserve default OpenCode agent behavior. Also includes the current main release candidate already validated on staging.

New

• GLM 5.2 is now selectable directly in the model picker; the "Auto" model sits behind a flag.
• Slack connect and request-access are separate steps now — connect right in a thread, and request access without being pushed through a connect flow first.
• Slack access nudges arrive as a DM and an in-thread notice so they're harder to miss.
• Agents no longer stop while they still have open to-dos — an always-on continuation check keeps a run going until its to-do list is actually finished.

Fixed

• The file viewer now opens dot-directories like .opencode.
• Free-tier and native Zen free-model availability resolve correctly in the model picker.
• OAuth and other backend redirects pass straight through to the browser instead of being swallowed — no more blank page on some connect flows.
• AgentMail inbox-limit errors are handled gracefully instead of failing the request.

Under the hood

• Release and staging CI plumbing: Vercel SSO bypass so the staging release gate runs end-to-end, and removal of the direct prod-fix workflow in favor of the staging-only promotion path.

AgentMail now returns a clear, browser-safe message when the inbox limit has been reached. Production fixes also now follow the normal staging-to-production release process instead of bypassing testing.

New

• Connect Slack and email channels directly from the project view — set them up in place without leaving the page.
• "Fix with agent" on a change request: when a merge is blocked by a manifest conflict, hand it to the agent to resolve it.

Fixed

• Inbound email now reaches your agent. The AgentMail webhook endpoint had been dropped from the API, so replies to your agent's emails never started a session — restored it, along with the Slack identity-bind endpoint that was dropped with it.
• Live preview proxy now caps its retry budget under the load-balancer idle timeout, so slow previews fail fast instead of hanging.

Promoted the latest tested release candidate to production. It includes maintenance and admin improvements, better account filtering, clearer missing-project pages, model-provider setup fixes, and more reliable free-tier model selection.

New

• Added the native Kortix marketplace runtime floor so new projects can start with curated skills, starter defaults, and marketplace install/update flows built into the project experience.
• Expanded the Marketplace interface, CLI commands, registry handling, and project creation defaults so skills can be browsed, installed, updated, and carried into starter projects consistently.
• Moved the managed AI model gateway into the default routing path behind the production master switch, with OpenRouter and Bedrock-backed managed model routing, AUTO model handling, and server-owned model configuration.
• Added no-restart warm-fork and sandbox runtime improvements, including build-time catalog baking and credential hot-swap paths for faster agent startup without restarting OpenCode.
• Added agent email channel support, Slack per-user identity controls, and improved channel/session selection behavior.

Improved

• Hardened the dev, staging, and production release topology: staging is the release-candidate branch, production promotion retags tested staging images, prod rollback is image-aware, and staging/prod deploy workflows apply database migrations in the right environment.
• Improved staging environment correctness, including staging database isolation, staging auth/runtime configuration, Daytona as the staging sandbox provider, and staging Cloudflare/API worker deployment.
• Improved session reliability across browser, terminal, PTY, tunnel, file upload, PDF rendering, and first-prompt retry paths.
• Improved frontend onboarding and project creation flows with marketplace starter selection, first-project bootstrap fixes, chat input polish, session sidebar persistence, and model picker stability.
• Improved gateway observability and runtime behavior with structured run-path logging, managed catalog support, session cost display fixes, and live env handling for router tools.

Fixed

• Fixed staging deploy dispatch, build, and promotion edge cases so staging image pins and release-source SHAs are preserved correctly for production retags.
• Fixed multiple auth and environment regressions in staging, including server auth env alignment and runtime config validation.
• Fixed CI and security scan issues around marketplace code, frontend build memory, Drata visibility gating, and staging QA/report publishing.
• Fixed channel and connector bugs for AgentMail, Slack, email inbox binding, profile inbox defaults, and executor call routing.
• Fixed warm snapshot and warm pool toggles so disabled settings remain disabled and stale build contexts self-heal.

Improved

• Faster, cheaper model calls: the AI model gateway now applies prefix prompt caching on the Bedrock and Anthropic transports, so shared context (system prompt, tools, history) isn't reprocessed on every request.

Fixed

• Blocked previews no longer break: when a site refuses to be embedded, the agent shows a link to open the preview URL instead of an empty frame.

Expanded model support and improved compatibility in the AI model gateway. Internal schema verification was also adjusted to keep releases moving while consistency checks were reviewed.

Improved model streaming reliability and expanded Amazon Bedrock model support. This release also corrected database configuration used by the gateway’s migration process.

Improved model streaming reliability, expanded Amazon Bedrock support, and added smarter fallback behavior when a customer-provided model key reaches a rate or usage limit. Gateway health reporting and Slack error handling were also improved.

Improved Slack channel reliability and deployment safety. Existing databases are automatically repaired when required Slack connector data is missing, and release checks now verify important database values to prevent the same issue from returning.

Infrastructure maintenance release. The production gateway deployment was moved to EKS and its certificate-region configuration was corrected. No major customer-facing feature changes were included.

LLM Gateway → production

• Promotes the full AI model gateway to production — a per-project router with native cost & usage observability, served at gateway.kortix.com.

Highlights

• Router — resolve → route → bill across OpenAI-compatible, Anthropic, Bedrock and Codex transports, with fallback chains and a circuit breaker.
• Managed models — Kortix Power (Claude Sonnet) and Kortix Basic (Claude Haiku) on AWS Bedrock.
• Per-project bring-your-own-key — bring your own provider keys, injected per session.
• Live pricing — every LLM call priced from the live models.dev feed (24h refresh) with a 20% margin; no hardcoded price tables.
• Observability — Overview, Cost (per-session LLM + sandbox compute), Usage (requests / tokens / latency / errors), Logs, Budgets, API keys, and a Playground.
• Per-session cost — LLM + sandbox compute attributed per session.

Follow-up reliability fix: removes a too-aggressive internal sweep timeout that could under-cover scheduled triggers at scale, and corrects a false scheduler-stalled health signal. More consistent on-time trigger firing; no other user-facing change.

Scheduled triggers (crons) are now resilient — no single trigger can hold up the rest.

A slow or stuck trigger fire (e.g. resuming a sandbox) no longer blocks the scheduler: each fire is time-bounded and isolated, so one trigger can fail and retry while every other trigger keeps firing on schedule. The scheduler self-heals — a stalled sweep is automatically reclaimed, so automations can't silently stop. Hardened background-worker leadership so an API-only node can never sit on the scheduler lease without running it. Added a stall watchdog + health signal so a frozen scheduler is surfaced immediately instead of going unnoticed.

Fixed a production issue where sessions could appear active after their sandbox had disappeared, consuming the account’s concurrent-session limit and blocking new work. The platform now detects and clears these stuck sessions automatically, stops orphaned sandboxes, and gives clearer Slack messages when a request is blocked by credits, capacity, or a missing session.

Stage scaffold.git for Daytona snapshot build contexts so template builds no longer fail before user Dockerfile steps. Reuse the shared snapshot build-context path across providers to keep required files consistent.

Sandbox lifecycle + compute billing (headline) Idle sandboxes now reliably auto-stop after 15 min of no real activity on every provider, and compute billing closes deterministically the moment a box stops — fixes sandboxes that kept running (and billing) for hours/days after work finished. Provider-agnostic reaper (real provider state = source of truth; idleness keyed off real turns), quiesce so an open tab can't resurrect a finished box, Platinum reprovision-on-open, gateway per-session usage attribution, provider lifecycle webhooks (/v1/webhooks/sandbox/*) with the reaper as a zero-config backstop, and a billing-invariant monitor.

Also in this release

• Executor unified into one CLI/MCP/SDK (, ); OpenCode title sync; compact session digests; preview env-sync retries (, ); revert Bedrock; credits never render as -0; dep bumps.

Fixes an intermittent production session provisioning failure for private GitHub repos. The shared per-project git mirror now resolves stored project credentials before clone/fetch even when a tokenless background caller wins the refresh lock, preventing unauthenticated cold-cache clones. Git repository authentication failures are also categorized as git-auth instead of being misreported as a Daytona provider failure.

Fix warm-pool claimed sessions so their sandbox token is re-scoped to the real session before the spare row is removed. Restart/reconfigure OpenCode after claim so Executor MCP, AI model gateway, and project config are available for manual and cron trigger sessions.

New

• Per-agent authorization — scope exactly what each agent can touch with [[agents]] in kortix.toml.
• Instant session shell — sessions open immediately with an optimistic create and a shared composer, so there's no wait to start working.

Improved

• Project home, configure, and composers now route through the instant shell for a snappier first interaction; workspace top bar refresh and background restored.
• Warm pool is now per-template opt-in (no global cap) — templates that benefit from pre-warmed sandboxes get them without tying up capacity for those that don't.
• The production backend now runs colocated with the database (London), cutting cross-region latency on every request.

Fixed

• Slack: exactly-once turn dispatch and durable, atomic credit deduction — no more double answers or missed credits.
• Terminal: fixed a PTY WebSocket reconnect loop when a JWT expired.
• Warm pool: send the Daytona preview token on the park health probe.

Sessions start faster and the project workspace feels smoother. Warm-start experiments were tuned and safely rolled back where they caused session errors, while health reporting and billing protections were improved. Slack direct messages also gained project selection and /kortix command support.

Prevented unexpected API restarts under heavy load. Each API instance now runs with more memory headroom, and autoscaling kicks in sooner, so the brief interruptions some requests saw during memory spikes are resolved

Product and infrastructure groundwork release. It included a refreshed landing page, early work on a skills marketplace and standalone model gateway, improved tracing, and more reliable sandbox cleanup. Most changes were behind the scenes.

Improved Slack and automation reliability. Slack sessions now use the same durable lifecycle as web, mobile, CLI, schedules, and webhooks. Trigger requests are queued safely when the system is busy, follow-up messages are less likely to be dropped, and release verification now checks the complete flow before promotion.

Sessions — more reliable runtime recovery and a refactored session lifecycle; terminal PTYs are now isolated per session; session branches are local-first and publish to origin lazily; the show tool fills the Actions panel height; the welcome wallpaper stays full-width when the side panel is open.

Browser & sharing — the browser preview stays mounted across panel switches; added public preview and file share links; Chromium for agent-browser is now baked into every session image.

Slack — clearer channel intro and App Home copy; unified canonical + bring-your-own into one manifest builder with per-project parity; the question tool no longer auto-answers outside Slack and is disabled in-thread.

Web — restored social avatar downloads and the full logo; added a /game-of-life page seeded from the Kortix logo.

This release focuses entirely on making sessions start faster and more reliably.

Improved

• Sessions open faster. The computer behind a session now warms up earlier and is prefetched as you navigate, so there's less waiting before you can start typing. Under the hood we also trimmed startup time (lighter tool loading, a pre-warmed runtime baked into the image).
• A single, clearer loading screen. Starting a session now shows one consistent loader with clear steps, instead of overlapping or flickering states.
• Titles appear right away. A session picks up its title as soon as the agent names it, rather than staying unnamed until your next message.

Fixed

• Sessions no longer get stuck on the loading screen — start-up now retries on its own when a transient hiccup (like a momentarily missing sandbox id) would previously leave it stranded.
• Your first message stays visible while the session connects, instead of briefly disappearing.
• Warm sandboxes are now prepared for the person actually opening the session, not always the project owner.

Session loading is now clean end-to-end:

The chat input no longer jumps to the top of the page while a session connects. No more brandmark 'arcs' bleeding through behind the loader on a fresh session. The loader and the session shell never show at the same time — connecting shows just the loader, ready shows the full session, never both at once. More reliable Slack session handling (session lifecycle now goes through the unified openSession path).

Session startup is now handled through one reliable flow that provisions, resumes, and connects the workspace. This fixes sessions that could remain stuck on a spinner until refresh and removes a stale Git lock that could block creation. File access and PDF/PPTX viewing were also rebuilt, sandbox access checks were strengthened, and Slack support was expanded.

Hardens the dual-backend deploy: CI now fails red if an ECS roll circuit-breaker-rolls-back (was silently green); managed-git Create-project keys made durable; GitHub App key parsing tolerates wrapping quotes. Carries the live fix for project-creation 502s.

Added fast, reversible infrastructure failover for the public API. The platform can now switch between two production backends without rebuilding, and every release deploys both so either can take over when needed.

New

• Connect your ChatGPT Plus/Pro subscription. Sign in once from a project's provider settings — or from the CLI with kortix providers login openai — and every session reuses it, no API key needed. It uses OpenAI's device login and stores the resulting credential encrypted, per project.
• Skills tab is now a real file tree. Browse a project's skills as a navigable, recursive tree.

Improved

• Slack is steadier. Agent questions no longer block a turn, so threads don't get stuck; a Slack thread now maps permanently to a single session that brings its own sandbox back as needed; and the flaky streaming widget was retired.
• Executor accepts YAML OpenAPI specs, with hardened spec parsing.
• CLI agents reach full programmatic parity, including parallel sub-agent orchestration.

Under the hood

• More API memory headroom (dev + prod) so the new ChatGPT device login can't exhaust a pod.
• Dev cluster tuning for low traffic (autoscaling and pod-disruption-budget adjustments).

Added isolated preview environments for pull requests, including automatic frontend and backend deployment, DNS, certificates, status updates, and cleanup when a request is closed. This release also fixed a sandbox snapshot build process that could consume excessive disk space.

Improved platform health visibility, sandbox snapshot management, stopped-session cleanup, and deployment reliability. The marketing site also received an early redesign.

Simplified production deployments by moving to standard rolling releases through Argo CD. Release monitoring now follows the active deployment directly, making rollouts more predictable.

Internal pipeline release — no product or API behavior changes.

Fixed

• Sessions started by Slack messages, schedules, and webhooks were only visible to the account owner — they now show up for everyone on the project. This applies to existing sessions too, so past Slack threads and trigger runs appear in the session list.

Improved

• Sessions in the sidebar now show where they came from, with an icon for Slack, scheduled, and webhook sessions — hover to see the trigger behind it.
• Click the SESSIONS header to filter the list: All, My Chats, Shared, Slack, Scheduled, or Webhook, each with a count.

Faster, safer releases. The production canary process was reduced from about seven minutes to about one minute. Security and dependency scans still run for visibility but no longer delay a healthy promotion. Health reporting now also shows whether warm snapshots are enabled.

Continued the Kubernetes and Argo CD rollout with improved canary analysis and additional session experience updates. This was primarily an infrastructure release.

Introduced the production Kubernetes deployment foundation with canary releases, automatic rollback, improved health checks, and safer release gating. This release also included billing and access-control fixes.

Fixed

• Named connector actions work again across apps (Salesforce, Google Drive, Box, OneDrive, WhatsApp Business, and more). Tool calls were failing with an unclear "HTTP 502" because the connected account was attached under the wrong property name for many apps, so actions ran without their credentials. The binding is now resolved from each action's own definition — existing connectors work immediately, no reconnect needed.

Improved

• When a connector call fails, the agent now sees the real cause — the upstream status and error message instead of a bare 502 — plus a pointer to the connector's raw request tool as a fallback. (Error responses moved from HTTP 502 to 500 so the message survives the proxy layer.)
• Connector call failures are now recorded with their reason, making them diagnosable in one step.

Mobile app v2

• Full account-management parity with web: members, invites, groups, roles, audit log (filters, diffs, CSV/JSONL export), tokens (PATs + service accounts), security (MFA, session controls), observability webhooks, and Git installations — all native. Plus a rebuilt Files page (create/edit/save, classic interface), Terminal + Browser side-panel tabs with a real ANSI PTY renderer, session menu parity (rename/share/delete/restart), per-project tab memory, offline boot fixes, and a broad visual polish pass (borderless lists, bottom sheets, skeleton loaders, haptics).

Team billing

• Upgrade/subscribe flow is now scoped to the project's account, not the viewer's primary account (fixes per-seat checkout charging the wrong account)
• Checkout/subscribe gated behind billing.write; Billing shortcut hidden for non-billable users
• Subscribe modal shows the live projected seat total
• Newly-joined invitees land on /projects instead of account settings

Web

• Delete-session dialog clarifies the branch is preserved

Project secrets can now be refreshed inside a running sandbox without restarting OpenCode. This release also prevents long-running migration checks from timing out and reduces browser-generated rendering noise.

Resolved widespread “Request timed out after 30 seconds” errors across sessions, secrets, permissions, change requests, and sandbox health checks. Database connection pooling and query timeouts were improved so slow requests no longer block unrelated work. Permission checks were also consolidated to reduce unnecessary network calls.

Desktop

• Product-only desktop app shell with a new Download apps page and a frontend-URL switcher.
• Visitor-tracking pixels suppressed inside the desktop app.

Channels and Slack

• Unified all channel message delivery into one canonical server-side path (removed the legacy queue drainer/storage/routes).
• Slack manifest webhook URL now derives from the public API origin; post-install OAuth now lands on the Customize → channels view; dev Slack app pointed at the new KortixDev app / dev-api.

Web and API reliability

• Brand-compliant container radii; third-party Sentry Promise.then tampering noise suppressed.
• Bounded the Daytona snapshot lookup so /sandbox-health can't hang.

Release process

• Promote pre-flight green-gate hardened (ignores the promote run's own check and superseded duplicate checks); deploy-prod retag now falls back to :dev-latest per image so a single-surface commit promotes cleanly.

Webhook triggers now support static-token authentication, making it easier to connect services that do not support HMAC-signed requests.

New

• Connectors: edit a connection's configuration after setup, plus a broad connectors UX overhaul.
• Sandboxes now hibernate instead of being destroyed, and resume in place — faster to pick work back up.
• New MDX blog, launching with the flagship Kortix article.
• The CLI now tells you when a newer release is available.

Improved

• Cleaner project tab bar and a modernized share dialog.
• The collapsed project sidebar rail now expands when you click the logo or Sessions.
• Refreshed landing-page SEO metadata.

Fixed

• Browser auth now works in sandbox previews (same-origin /supabase proxy; relative BACKEND_URL handled correctly).
• Sandbox previews are now transparent to upstream framing and CSRF checks.
• Resolved a migration heartbeat index ordering bug and version collisions.

Fixed

• Premium model access is now gated by your subscription tier.
• Account migration no longer errors when a legacy data table is absent.

Improved

• The "New" and "Edit with agent" actions in Customize now show a loading state while they work.

Added session pinning and began integrating Platinum as an additional sandbox provider alongside Daytona.

Migrated conversations now restore correctly because the OpenCode archive keeps the database filename expected by the restore process.

Updated AI model gateway authentication to use personal access tokens, improving secure access from the executor runtime.

Improved migration support for legacy Suna projects. No major new customer-facing features were included.

Fixed an error when creating privately shared connectors and made the project Git connection migration more reliable, including recovery for previously failed migrations.

Migration history now loads the latest 25 items by default and supports paging through older records, making large migrations easier to review.

Auth: magic-link sign-in no longer silently falls back to localhost for the redirect target. Connectors: the Pipedream connect popup is now usable inside the Customize modal. Memory: branded memory tool views + a fix for memory create durability. Billing (dev): self-contained Stripe test sandbox for local per-seat checkout. Infra: documented kortix-alb-waf *_BODY rules set to Count.

Improved Stripe webhook processing so per-seat subscription changes reconcile correctly even when events are delivered more than once or handled by multiple application instances.

The “Claim seat-based pricing” option now appears only for eligible legacy customers. This release also improved local development isolation and prevents branch-name conflicts from leaving incomplete workspaces behind.

Fixed subscription-tier detection so active per-seat customers receive the correct paid features and access.

Connected the managed AI model router directly to session sandboxes for more consistent model access and authentication.

New

• Project memory — agents get a first-class memory tool to read and write a durable project brain in .kortix/memory/, replacing the old prompt-injection plugin. The memory-reflector keeps it curated on a schedule.
• Runtime feature controls — turn built-in capabilities (memory, web tools, terminal, the show tool, the executor) on or off per project in kortix.toml [runtime], or enforce them per session. disable_all runs a session as plain OpenCode.
• kortix init is now standalone — like create-next-app, it scaffolds a new Kortix project in its own fresh directory.
• Experimental feature flags — a per-project system to gate work-in-progress features (Apps, Agent Tunnel).
• Typed API + live docs — the API is fully typed end to end, with interactive reference docs at /v1/docs.

Improved

• Leaner project starter — the full agent runtime ships as editable source with a cleaner default layout (the Slack skill is now kortix-slack).
• kortix ship walks you through connecting any connector that still needs auth.
• Mobile-responsive marketing pages and a full-screen mobile nav; chat links and file paths open in the active session panel.
• Per-account project limits by plan.

Fixed

• Subscriptions are scoped to the owning account.
• Several API request-validation and auth-ordering regressions.
• Code-scanning (CodeQL) findings.
• Internal: the API was decomposed so every file is under 1k lines, and CI now rebuilds only when the dependency closure changes.

Fixed

• The site was showing "Something went wrong" on every page after the last release. The page metadata was being built from an environment value that wasn't a valid URL, which crashed server-side rendering across the whole site. The base URL is now validated (and falls back to the canonical domain), restoring all pages.

New

• Contact page demo lead qualifier with a paid-gated founder concierge flow.
• Rebuilt /developers page — brand-aligned and closer to the product.
• Revived the admin accounts console backend.

Improved

• Background workers (cron, triggers, sweeps) now elect a single leader across multi-replica Fargate, so scheduled work fires exactly once instead of once per replica.
• Maintenance flags moved to the database (dropped Vercel Edge Config).
• Local/dev/prod environment flow standardized on dotenvx, with pre-commit auto-encryption of committable .env files.

Fixed

• Vercel production build (a lint error that failed next build).
• Vercel pnpm install falling back to npm.
• An OpenTelemetry dependency pin that was crashing next dev.

Under the hood

• Added the ke2e black-box end-to-end API test suite (work in progress).
• Compliance/Drata key handling.

Release-process validation only. This release confirmed that version numbers stay synchronized automatically after publication. No customer-facing application changes were included.

Strengthened the AWS security baseline with improved audit logging, threat detection, network visibility, backups, firewall protection, and role-based access. It also introduced compliance checks and a review-gated production release process.

All accounts view — see and search your projects across every account you belong to from one place, grouped by account.

Invited teammates now reliably land on the project they were invited to — fixed a case where the access grant could be skipped when accepting an invite.

Inviting someone is now near-instant: the request no longer waits on the invitation email (now sent in the background) or a slow account lookup.

Switching accounts from an account settings page now takes you to that account instead of staying on the previous one.