What's new in version 3.6

3.6 is the voice release: for the first time you can talk to the agent like on a phone call, interrupt it, and give it commands about the application itself without touching the mouse. It also brings two refreshed AI providers and a much more solid Database section.

Ready in two minutes: the welcome guide

The first time you open the app, a five-step guide gets it working: language, connecting the AI (with your account, with an API key or with a local model that downloads itself), choosing a folder and testing voice. Every step can be skipped, and you can see it again from your account menu.

There is also a permanent status icon in the top bar: it tells you whether anything is missing before the agent can answer — connected AI, valid model, internet, helper programs — and every warning comes with a Fix it button that takes you to the missing step. And chat errors now come out in plain language, with the action that solves them.

Talk to the agent, for real

Real-time conversation — enable it in Settings → Voice and reading and press the conversation button in the chat. The agent greets you with “I’m listening.” and from then on:

It listens while you speak: nothing to press to start or to end the sentence.
You can cut it off mid-word and keep talking; it goes quiet instantly.
Live captions of what you say and what it answers.
If you go quiet, it asks “Are you still there?” instead of hanging up.
It answers with the voice you choose — Edge, Groq, Kokoro, Pocket or Chatterbox — and you can change it without hanging up.
When the answer includes code it doesn’t dictate it: it says “I’ll leave the code on screen” and writes it.

It works in the application’s 17 languages and also from your phone, over your home WiFi network.

And there is nothing to download: the Windows, Linux and macOS installer carries the voice agent, the server and the models inside, so Conversation mode works right after installing — even with no internet connection — without the first-time wait the preview builds had.

A floating orb, always on top of other windows, to follow the conversation while you work on something else. It shows the status (listening, thinking, speaking), a caption line and its own buttons to pause, return to the window and hang up. Drag it wherever you want and it remembers where you left it. You choose whether it appears never, when the main window is minimized — which includes closing it to the tray — or whenever voice is active.

You can give it three faces: Orb, Ring (three thin rings spinning) or Pixel (a 7×7 grid that fills up with your voice), with a live preview in the selector. And if you’re not sure it will show up, the Try widget button shows it for five seconds and writes the diagnosis underneath: whether the window was created, whether the system considers it visible, where it ended up and how many monitors it sees. If the saved position falls outside the connected screens, it returns to the center-right on its own.

“Hey Context”: have it listen without touching anything

With always-on listening you don’t even need to press the button: you say “Hey Context” — or “Oye Context”, or “Context” — and the conversation opens on its own, with the widget in front of you.

It ships off, and on purpose: it’s the only feature that opens the microphone without you asking. While it listens there’s an indicator next to the voice button that pulses with the microphone level, so there’s never any doubt. Everything happens on your machine: an energy detector discards silence without transcribing anything, and only the short bursts where someone speaks go through a small Whisper — about four tenths of a second of CPU each, and nothing at rest. With noise it demands hearing it twice in three seconds (three times if you say only “Context”), waits eight seconds before firing again, and never listens while a conversation is open or the agent is speaking.

Voice commands for the application

Now the agent drives the app for you while you talk: “create a new chat”, “open project Invoices”, “switch to model Gemini”, “read me the last answer”, “pause”, “hang up”, “show the window”. The full list is on the widget page.

xKiro: 110 models with a single key

New xKiro provider: a gateway with more than 110 models from GPT, Claude, Gemini, DeepSeek, Qwen, GLM, Kimi, MiniMax or Grok behind a single key — and more than 40 free models on its free tier.

Gemini speaks through its own API

Gemini API Key no longer goes through the OpenAI compatibility layer: it uses Google’s native API. In practice:

“Model overloaded” 503 errors are retried on their own (2, 5 and 10 seconds) instead of cutting your turn short.
The Reasoning switch really controls Gemini 3’s thinking level.
Errors arrive in your language and with a hint of what to do.

Database and Developer: right where you left it

Switching sections no longer costs you the work you’ve done: the SQL console and Developer mode keep the connection, the explorer tree, the open tabs and the cursor of every script. Plus:

Transparent reconnection and heartbeat for SQL Server and Oracle: if the server closes the session, the app reopens it without bothering you and retries once the query that failed because of the network.
Batches per engine: GO in SQL Server (with GO 5 to repeat) and / in Oracle, respecting strings and comments; errors tell you which batch and which line of the script.
Scripts that touch several databases on the same engine: SQL Server prepends the right USE and warns if the script names another database, with a button to rewrite it.

And you decide what the agent may do on each database

Every connection now has its Agent permissions button, with three presets — Read only (the factory default), Development and Administrator — and eleven individual switches: read, view schema, write, delete, create and alter objects, DROP, run procedures, transactions, export to file and ask before every write. Plus a cap on affected rows without asking.

It’s not a warning: what you switch off never reaches the database. The assistant checks it before every query and explains it in plain words (“I don’t have permission to delete on this connection; enable it in Agent permissions”); what does need confirmation tells you why and how many rows it’s going to touch, and the irreversible is always confirmed. A mixed script with a single forbidden statement is denied as a whole.

The mobile app catches up (1.0.30)

The phone stops being a viewer and becomes a command post:

Conversation mode with the same experience as the desktop: spoken greeting, live captions, waves that follow your voice, pause and resume, and Retry.
Voice commands that run on the phone: “create a chat called X” takes you to the new chat on the phone; “open the chat about X”, “switch to model Sonnet”, “read me the last answer”, “pause” and “hang up” are handled right there. The ones that only make sense in front of the PC are forwarded to the desktop, which confirms them back to you.
Attach photos and files from the paperclip, including the option to take a photo.
See the files the agent touches: in every read, write or edit operation the path appears; tap it and it opens in a read-only viewer.
The red square (“Stop the turn”) cuts the turn and its subagents, and clears whatever you had queued.

The APK is downloaded from the downloads page, with a QR code to install it from the phone itself. Conversation mode still needs to be on the same WiFi network as the PC (not through the tunnel) and the desktop turned on.

The terminal stops being the poor relation

Context Code has always been one program with two faces, but from the terminal it was hard to know where you stood. 3.6 fixes that with three new commands — and a documentation section of its own:

contextcode conexion (also info or whoami) answers “where is everything?”: version and executable, whether you’re desktop+CLI or CLI only, the configuration and data folders, the database, the log, the remote link status and the paired phones. It shows no secrets: the URL with token only appears if you ask for it with --enlace or --qr. With --json, the same for a script.
contextcode instalar-cli puts the short command in the PATH without asking for administrator, right where the installer can’t do it: AppImage, macOS and the Windows .msi. (The .deb and the .exe installer already did.)
contextcode remoto and contextcode chat --remoto: chat from your terminal with the Context Code on another machine, the one at home from the office or the one on the server from your laptop. It pairs like one more device — exchanging the QR token for one of its own, which doesn’t expire — and, the important part, approvals are answered in your terminal: the agent over there doesn’t sit waiting for someone in front of that machine.

SSH tunnels stop dropping

If you used an SSH workspace and it cut out every so often, the culprit was the home NAT or the VPN, which recycle idle sessions because they can’t see SSH’s encrypted traffic. Now there’s keep-alive on both layers, the app detects the dead tunnel and goes back to working locally on its own (instead of chaining three-second waits per command) and remote chats withstand outages of more than two minutes before giving up.

What came next: 3.6.1, 3.6.2 and 3.6.3

Updating stops being a chore

The new version downloads inside the app, with a progress bar and megabytes, and is verified with SHA-256 before running anything (“Checking the installer…”). You can also See what’s new without leaving the app, or leave it for Later. If something fails, Retry; the manual download link stays as the last resort, not the first option. On Linux .deb it gives you the command already written and copyable; on AppImage and macOS the handover is automatic. All the details, in Updates. (The intermediate step of choosing between “Install now” and “Install on exit” didn’t last long: 3.6.6 removed it — see below.)

Big chats open instantly

Opening a chat with a long history took between 1.5 and 2.6 seconds; now it’s around 0.4. And coming back to the chat from Developer or from Database no longer freezes the interface.

The results grid behaves like a spreadsheet

Select rows with a click, Ctrl+click and Shift+click, all of them with Ctrl+A, and Ctrl+C copies as TSV ready to paste into Excel. The context menu adds copying with headers, as CSV or as INSERT. Context statements (USE, SET, DECLARE) no longer open a result tab, every “Resultado N” tab has its X and there’s “Close all results”. If the result came trimmed, it warns you before you copy half a report without noticing. See Database.

Subagents you can throw away

A chat that has delegated a lot piles up subagents in the sidebar. Now they can be deleted: one with the X, or from the parent chat “Delete finished subagents” and “Delete all subagents”. The ones still running aren’t deleted lightly — you’re offered Stop and delete or Just stop. See Agents and orchestration.

Voice

The widget now uses the application’s theme, the caption fits in two lines, and with “Show widget: when the main window is minimized” it appears when you minimize or hide the window even with no conversation running, with a “Talk to Context Code” button to start one. The voice detector is also stricter: fewer turns opened by noise. And no more echo: it no longer plays twice.

And a couple of clean-ups

The “Context Code server” card disappears from Settings (it was a support thing). And the mobile app 1.0.31 drops the dictation button — the phone’s keyboard already does it better — and fixes the “missing chat parameter” error when opening the voice conversation.

3.6.4: chats as tabs and a real Git panel

One tab per chat

Chats now open as tabs in the same bar as the files and the SQL console —“Project Invoices - Review the login”—, with a green dot when the chat is working and a ”!” when it is waiting for your answer. You jump between conversations with one click or with Ctrl+Tab, and activating a tab also takes you to that chat’s project (explorer, editor and Git). Closing it stops nothing: the chat keeps working in the background, and it tells you so the first time. Tabs are remembered when you reopen the app, and the “Chats as tabs” switch in Settings → General brings back the old behaviour. See Your first chat.

Pinning and archiving project-less chats too

Right-clicking any chat in the sidebar —including those on the “Chat” tab, which had neither before— offers “Pin chat” and “Archive chat”. Pinned chats stay at the top and survive a restart; archived ones wait in their “Archived” section, and the search finds them with a “Restore and open” button.

The Git panel, at GitHub Desktop level

Two labelled tabs with a counter, Changes and History. History brings the author’s avatar, relative time in your language, branch and tag labels, a search by message/author/hash, “Select branch to compare…” and “Load 100 more commits”; the commit detail, a copyable short hash, +N −M and the files with their status. And diffs are shown inside the panel with the Monaco editor: minimap, change markers in the scrollbar, line numbers on both sides, side-by-side or unified, folded unchanged regions and “Open in the editor” —with a simple fallback viewer for files over 2 MB—. In Changes, one click shows the diff and a double click opens the file in the editor. Along the way, a bug that made single-line commits disappear from history was fixed. See Git panel.

3.6.5: browsing without filling the bar, and Git with no surprises

A preview tab, like in a code editor

A single click on a chat in the sidebar no longer opens a new tab: it shows it in a provisional tab, with the title in italics, which the next single click reuses in the same place. That way you can look at ten conversations without ending up with ten tabs. The tab stays as soon as you do something that is not a peek: double click (on the chat or on the tab), typing a message or dragging it. You can turn it off in Settings → General with “Open chats as a preview with one click”. See Your first chat.

You see at a glance what is left to push

In the Git panel’s History, commits that are not on the remote yet carry a ↑ pill (“Not pushed yet”), and above the list there is a strip with “N commits to push · Push” and “M to pull · Pull”. If the branch has no remote it says so —“This branch has no remote · Publish branch”— and marks nothing, because there is nothing to compare against.

The diff in its own tab; the files as a tree

Diffs are no longer squeezed into the panel column: a click on a file —in Changes or in a commit— opens (or updates) the editor’s diff tab, now with a minimap, change markers in the scrollbar, folded unchanged regions and side-by-side ⇄ unified. The tab is reused; with Ctrl+click you open a separate one. A folded preview, off by default, remains in the panel. And the file lists —a commit’s and the Changes one— become a folder tree in an accordion, with a count and +/− per folder, single-folder chains compacted, a Tree/List switch that is remembered, collapse/expand all and keyboard control with ↑ ↓ ← → and Enter. See Git panel.

3.6.6: updating is one button again

The optional update notice had been split into two steps —“Download” and, a while later, “Version X ready to install” with “Install now” and “Install on exit”—, which forced you back to the card for a click nobody had asked for.

It is the usual card again: “New version X available” with Update & restart, Later and the ✕, and See what’s new as a small text link. That single button does the whole way in the same card: download with progress (“120 / 389 MB”), SHA-256 check (“Checking the installer…”) and installation (“Installing and restarting…”), just like the mandatory ones.

Nothing underneath changes: the latest version is re-checked before downloading, on failure there are Retry and Open in browser, and whoever installed via .deb still stops at “Version X ready to install” with its copyable command —that package is installed by the system, not by us—. See Updates.

3.6.9: the graph understands your code, not just your files

The code graph stops being a map of files and becomes a map of symbols: which function calls which, what inherits from what, and what crosses the border between the front end and the back end.

Questions that used to cost half a dozen searches. Now it is enough to say “explain handle_livekit_join to me and what breaks if I change it”: the agent answers with a single query that brings back the whole function, who calls it, what it calls and the files that depend on it. Behind it there are four new queries — explore, symbol, callers/callees and impact — with an impact radius up to depth 4.
Real TypeScript imports. They are read from the syntax tree, and the tsconfig.json aliases, the barrels (index.ts) and the re-exports are resolved: an import { X } from "@/core" stops counting as an external dependency and points at the real file. Inheritance is drawn too (extends, implements, impl Trait for, Python base classes), and C, C++ and C# are now parsed like the rest.
Front↔back bridges. Every invoke("…") in the front end is joined to its #[tauri::command] in Rust — and the ones pointing at a command that no longer exists (buttons that do nothing) are listed in the GRAPH_REPORT.md report. HTTP routes from Express, NestJS, FastAPI, Flask, ASP.NET and axum become nodes with their handler.
In the Graph view there are new types in the legend and the filters: Inheritance, Implements, Tauri invoke, Route → handler and the HTTP route nodes (shortcut 7).
And dependencies no longer eat it: when the graph’s caps are handed out, your code goes first and the vendored folders after, in an order that stays stable across regenerations.

Typesafe AI: the small decisions stop being guesswork

Many of the app’s internal decisions —which model to use for the turn, which skills to load, whether an action is delicate, which specialists a plan needs— were made from hand-written keyword lists. With a Typesafe AI key they are actually decided, and with a confidence number: below the threshold the old rule comes back, so a decision is never worse than the one you already had.

The turn’s model when the selector is on Automatic, and each orchestrator subagent’s model: a mechanical task drops to the fastest, cheapest of your profiles, a redesign moves up to the most capable one. If the agent’s .md already declares profile: or model:, your file wins.
Relevant skills and risk in “Ask me first”.
The intent of what you write (do you want an explanation, or the work done?) and the domains it touches, which is where a plan’s proposed team comes from.
When the decision is its own, you see it: “Model chosen by Typesafe: … (confidence 0.87)”.

It is optional and cheap ($0.042 per million input tokens; a month of work is cents). With no key, or if the service fails, everything behaves exactly as before.

The editor knows where everything is

Go to definition now really works: Ctrl+click or F12 on a function, class or variable takes you to where it is defined, Alt+F12 peeks at it in a pop-up without leaving the file, and Shift+F12 lists the references. It is tested against real C#, TypeScript and Go servers; for C# two things had to be fixed that left the server silent (it never got an answer to its configuration request, and the solution path arrived with a Windows extended-length prefix). If the language has no server installed, the app says so and offers to install it. See Editor.

Run, like in Visual Studio

F5 no longer lists things that are not your project: it detects what is in the folder (.NET, Node, Python, Rust, Go, Java…), groups it by project and shows it with the language icon instead of the runtime name. One line per configuration, Ctrl+Shift+B for build targets, and everything can be pinned in .context/run.json. See Run.

Typesafe chooses with numbers, and tells you what it spends

Typesafe’s automatic mode no longer decides with adjectives: every candidate model carries its real price per million tokens and the measured speed of your previous turns, and profiles that just got a 429 or 503 drop out of the list while the quota lasts. The line under the message now reads “Model chosen by Typesafe: … · among 12 models, 2 rate-limited”. The Settings card gets a monthly limit in USD (once exceeded, every function switches off and you are warned once) and a “This month: N decisions · tokens · USD” line; the spend also shows in the Usage panel. The welcome guide has an optional step to paste and test the key, and without a key the “Automatic (Typesafe)” row shows disabled with a hint on where to set it up. From the phone and the tunnel web you can also put a chat on automatic and see the decision, and in the terminal contextcode chat --model auto works.

SVG with live preview, and a data console you can stop

.svg files open in their own tab: the code on the left (with Format for XML that comes in a single line) and the live preview on the right, with a checkered background, zoom, drag, real size, Ctrl+S to save, an invalid-SVG warning and Export PNG at 1x, 2x or 4x. In Database, durations are readable now (“1 m 35 s 525 ms” instead of “95525 ms”), while a query runs the bar says “Running… 0:05” with the previous grid dimmed and per-statement progress, and there is a Stop button next to run (Alt+Pause or Escape) that really cancels on SQL Server, PostgreSQL, MySQL and SQLite and leaves the run marked “Cancelled by the user”.

Key Vault: your secrets never reach the AI

New Key Vault panel (padlock next to Skills and MCP). Store passwords, tokens, SSH keys and server data (host, port, user and its password or key) encrypted with AES-256-GCM in .context/secretos/equipo.enc, with the master key in the system keychain. The agent asks permission to use a secret, never for its value: the key is injected into the command, the HTTP header or the trusted MCP server without going through the model, and everything that comes back from a tool is masked before it reaches the AI, so echo $TOKEN, env, cat .env or git remote -v with the PAT in the URL return «secreto:id» instead of the value. If you paste a credential into the chat, a banner offers to store it and send only the reference; when you open a .env or an appsettings.json with secrets, the editor tells you. With a strength validator (a key like Ds910913@ is flagged as weak), a generator, “Test connection” for servers, a usage audit log and an encrypted emergency export.

Context building Context

When the open project is Context Code’s own source code, the agent knows it: it cannot close or kill the instance it runs in (not even with Full access), and to test changes it uses pnpm tauri:demo, which starts a second isolated instance with its own configuration, the title “Context Code Demo” and an amber badge so you never confuse it with yours. Settings → General shows the Self-build card with versions, PID and the button to open the demo.

Subagents with the profile or model you say

“Launch a translations agent with the DanielSalamanknf profile” or “with GLM” now works: the subagent tool and every step of the orchestrator plan accept profile (by id, readable name or provider) and model, with the list of your connected profiles visible to the agent. What you ask in the chat wins over the agent’s .md, and that wins over Typesafe’s automatic choice.

Updates with a deadline

An installed version has 2 days from the moment the next one is published to update; after that it becomes mandatory. The notice tells you how many days are left. This 3.6.19 is the first one that applies it.

Two new ways to share a conversation, each with its own owner:

With someone outside, through the web link. In the chat menu, Share this chat… generates a link (and its QR) that opens only that chat: you choose View only or Can write, how long it lasts (1 hour, 1 day, 7 days or until you revoke it) and, optionally, the person’s name. Whoever enters sees the conversation and, if allowed, can keep working; their messages show as “Ana (guest)”. The agent’s approvals keep showing only on your desktop, never to the guest, and Key Vault secrets stay masked. Everything else in the app (other chats, projects, providers, files) answers “out of scope”. Live links can be seen and revoked from the chat or from the Connections panel.
With your team, through the repository. Share with the team saves the chat in .context/chats-compartidos/ as a one-line-per-turn file, with each turn’s author, and from then on every new turn is appended on its own. After a push, the rest of the team sees it in the project’s Shared by the team section, greyed out until they press Activate: then they follow it with their own provider and model, and what they write goes back to the repo. Git merges lines from two branches without conflicts (merge=union is set up automatically). No server, no internet, nothing exposed; any credentials found are redacted on export.

And also

Much less memory with several chats open. Each chat started its own full set of MCP servers (files, git, SSH, email…) and kept it alive until the app closed: with six chats there were six copies of each one. Now each server starts only once and every chat in the project shares it; only the Playwright browser is still one per chat. A server shuts down when the last chat stops using it.
Stop now really stops what you launch with F5 in Developer mode. It used to close only the first process (for example cmd or pnpm) and left alive the program started underneath it (dotnet, node, the dev server), which kept holding the port. Now the whole process tree is closed.
If the administrator forces an update on your computer, the notice shows up again even if you had dismissed it.
No more stray processes after closing the app. Everything Context Code starts (MCP servers, voice, language servers, tools, local models) now closes with it, even if it crashes or restarts to update. Before, they could stay alive for days and one of them could exhaust the computer’s memory until Windows started showing “0xc0000142” errors when opening git, cmd or where. What you open outside the app (browser, Explorer, terminal, editor) stays open when you close it.
If a helper program fails to start, the tool gets the error right away instead of waiting behind a Windows dialog, and each command launches fewer intermediate processes.
Chat tabs are wider (up to 320 px) and shrink evenly when there are many: the project and chat name are now readable.
Settings → General no longer shows the “Self-build” card: it appeared in every project. The agent’s rules over its own code, the Demo badge and pnpm tauri:demo are unchanged.
From the tunnel web you can now attach images and files: a clip next to Send, camera on the phone, drag and drop onto the chat and paste with Ctrl+V; large photos are downsized before uploading and the limits (8 files, 12 MB) are warned about before you exceed them.
When sharing with the team, if .context/ is ignored in the repo the app tells you the exact rule and does not share halfway.
The agent heartbeat no longer enters your working chat: it uses its own “Heartbeat” chat, defers if you are typing and its “nothing to report” does not stay in the history.
Retry waits for Anthropic, OpenAI and Codex (429, 529 “Overloaded” and 5xx) now show on screen with the cause, the wait and the attempt, as they already did for Gemini.
In the Git changes list the folder is truncated and the file name is always visible, like in GitHub Desktop.
Archiving a chat from the Chats tab no longer sends you to Projects: you stay on the neighbouring chat of the same list, and the tab only changes when you open a chat of the other kind.
Duplicate in the file explorer’s context menu: it creates the copy and leaves it ready to rename.
With Gemini API Key, when Google throttles your quota (429 or 503) the retry shows on screen with the wait and the attempt number, and the error explains it is the key’s quota. HTTP connections are reused between requests.
MCP servers started with npx or uvx use the bundled runtimes, and arguments containing < or > no longer break the command on Windows.
The Conversation button can no longer crash the application.
Multi-cursor in the chat composer, like in the code editor.
The database object explorer scrolls horizontally.
The Linux Server card on the downloads page gets its installation instructions back.
The development build isolates itself from the installed app on its own.

How to update

Windows, macOS and desktop Linux: the application itself notifies you, downloads it and verifies it — see Updates.
Linux servers: contextcode update, or the same curl … | bash from the installation — see Context Code from the terminal.
Android: the app notifies you of the new version and takes you to install it.