Snowflake CoCo Desktop became generally available, so I tried out all the new features and operational features
This page has been translated by machine translation. View original
Kawabata here.
Snowflake's AI development environment, CoCo Desktop, became GA (generally available) on July 21, 2026.
This article covers the main new features since the Preview period (Memory, semantic code search, multiple sheets in SQL Playground, etc.) and the operational/governance features worth knowing about at GA (usage history view, credit limits, Managed settings). Note that this article uses the current official product name, "CoCo Desktop."
Installation, basic usage, and MCP integration are covered in the following articles and will not be repeated here.
【Update】
I was selected as a finalist in the "RISING COMMUNITY LEADER OF THE YEAR" category, APJ slot, of the Snowflake Community Awards.
Please see the link below for details.
Overview of CoCo Desktop GA
CoCo Desktop is a native desktop application for macOS / Windows, positioned as the standalone IDE edition of the Cortex Code (CoCo) family.
| Form | Overview |
|---|---|
| CoCo in Snowsight | Web-based (within Snowsight) |
| CoCo Desktop | Standalone IDE for macOS / Windows |
| CoCo CLI | Command-line tool for local shell |
The availability conditions and billing at GA are as follows.
- Available on Commercial accounts with cross-region inference enabled (Gov, VPS, and Sovereign accounts are not eligible)
- When used with an existing Snowflake account, pay-as-you-go billing based on token consumption
- For individual developers, a subscription with a monthly usage allowance is available, with a 30-day free trial from registration. After the trial ends, it transitions to a paid subscription unless cancelled; if the monthly allowance is exceeded, CoCo Desktop cannot be used until the next billing period
- Separate from CoCo Desktop usage, standard Snowflake charges apply for warehouses and storage used during SQL execution
- Snowflake's model terms apply to pass-through usage of the underlying models
Note: CoCo Desktop itself is GA, but within the Cortex Code family, MCP support, plugins, Agent SDK, and ACP support remain in Preview as of the time of writing. In particular, ACP is a feature for using CoCo CLI as the agent backend for editors / IDEs, and is not a feature of CoCo Desktop.
Prerequisites
- The active role requires the following database roles
SNOWFLAKE.COPILOT_USERSNOWFLAKE.CORTEX_USERorSNOWFLAKE.CORTEX_AGENT_USER
- By default,
SNOWFLAKE.COPILOT_USERandSNOWFLAKE.CORTEX_USERare granted to the PUBLIC role.SNOWFLAKE.CORTEX_AGENT_USERis not granted to PUBLIC by default and must be explicitly granted to the role that needs it - Cross-region inference must be enabled on the account
Note: Revoking
SNOWFLAKE.CORTEX_USERfrom PUBLIC will cause the loss of access not only to CoCo Desktop but also to other Covered AI Features including Cortex AI Functions (AI_COMPLETE, etc.). If you want to control only CoCo Desktop usage, the official documentation recommends using the daily credit limit parameter described later.
- Semantic code search requires access to the
snowflake-arctic-embed-l-v2.0model
Test Environment
- Test date: July 22, 2026
- CoCo Desktop: v1.20.0
- OS: Windows
- Snowflake: Enterprise edition
Trying Out the New Features
Memory (Cross-conversation memory)
A feature that allows the agent to remember facts (preferences, project context, etc.) across conversations and automatically recall them in new conversations. The memory is stored as Markdown files under ~/.snowflake/cortex/memory/, with two scopes: global memory shared across all workspaces, and project memory specific to a particular workspace.
It can be enabled and managed in the Memory section under Agent Settings → Personalization.
Note: Memory is for persistent context and does not store the temporary state of the current task. Also, Reset memories cannot be undone.
Custom instructions (Always-applied custom instructions)
Instructions that are always applied to the agent can now be managed on a dedicated page. Enter instructions in the editor under Agent Settings → Personalization and save them; they are saved to ~/.snowflake/cortex/AGENTS.md and applied across all workspaces.
Configuration content
# Basic policy
- Responses should be in Japanese
- Comments within code should also be written in Japanese
# SQL conventions
- SQL keywords should be written in uppercase (SELECT, FROM, WHERE, etc.)
- Table and column names should be written in lowercase snake_case
- Do not use SELECT *; specify required columns explicitly
# Snowflake-specific rules
- Queries for verification should explicitly specify the WAREHOUSE
- Operations with cost implications (full scans of large tables, etc.) should be warned before execution
# Output format
- Step-by-step instructions should be summarized concisely in a numbered list
Let's check with Please tell me about the setup procedure for CoCo Desktop.
The text in the red box suggests that the Custom instructions settings are being reflected.
On the same page, you can also control the on/off of built-in tools (Web Search Tool / Web Fetch Tool / Notebook Tools), and the toggles take effect immediately.
Note: The limit for Custom instructions is 512 KB. Also, using the Web Search Tool requires account-level permission (enabling the
ENABLE_CORTEX_WEBSEARCHparameter).
Semantic code search (tgrep)
A feature that allows you to search a codebase by "meaning" using natural language. It uses Snowflake Cortex embeddings (snowflake-arctic-embed-l-v2.0) and can identify relevant code with queries like "the part that validates the connection before executing a query" rather than exact keyword matching.
By default, indexing is not automatic and requires explicit opt-in by the user. Enable it from Agent Settings → Indexing.
- Open Agent Settings → Indexing
- Turn on
Enable semantic search (tgrep)(global setting shared across all workspaces) - Turn on
Search this workspace(setting per current workspace) - Use
Index workspaceto build an index for the current workspace
※The CoCo Desktop workspace contains jaffle-shop from dbt-labs.
After building the index, asking the agent about the location of code in natural language identified the relevant file.
※I felt it was difficult to clearly judge the effect of index building with this small repository alone. On the other hand, since code and documentation are indexed in chunks, it seems particularly effective for larger repositories or cases where you want to search for specifications or implementation intent in natural language.
Note: Not available in remote / virtual workspaces such as Remote-SSH or dev containers (local execution only).
Context management and /compact
A context window that visualizes token consumption during a conversation and a /compact command that summarizes the conversation to free up tokens have been added.
Hovering over the context window in the lower right of the message input field displays a popover showing a breakdown of token usage.
Running /compact in the middle of a long conversation summarizes the conversation history, freeing up tokens while continuing the same thread.
Changes panel
When the agent modifies files, a summary card showing "N files changed" is displayed, allowing you to review changes using a unified diff, changed file tree, and scope selector. Accept / reject is also possible at the file level.
Multiple sheets in SQL Playground
A lightweight SQL editor built into the right panel of Agent Manager, which now allows you to manage multiple SQL sheets (.sql buffers) per workspace.
- How to open: SQL Playground icon in the right toolbar, "Open SQL Playground" in the Command Palette, or the "Open in SQL Playground" action from agent results
- Execution: Run button or ⌘Enter (macOS) / Ctrl+Enter (Windows). The statement at the cursor position is executed
- Sheet management: Create new, rename, delete, and organize by drag & drop in the sidebar
Can also switch to chart view
Note: SQL Playground sheets are not source files under the workspace; they are saved in a scratch area at
~/.snowflake/cortex/sql/<workspace-id>/. Since sheets are auto-saved to a workspace-local area, they could at least be used continuously after restarting CoCo Desktop in the test environment. If you want to use Git management or normal editor features, you can open them as an editor tab via "Open in Editor" (the sheet on the Playground side remains as is).
Trying Out Advanced Features
Each of these could fill an entire article on its own, so this article covers only minimal operational verification.
Agentic Notebook
A feature that allows the agent to directly manipulate Jupyter notebooks (.ipynb) from the chat. It autonomously creates, edits, and executes cells, reads output, and inspects DataFrames (pandas / polars / PySpark / Snowpark supported). As a built-in feature, no additional feature enablement is required on the CoCo Desktop side. However, executing cells requires an available Jupyter kernel such as a local Python environment, conda environment, or existing Jupyter Server (when using Snowpark, dependencies such as snowflake-snowpark-python must also be installed on the kernel side).
When instructing the agent to create a Notebook that creates a sample DataFrame, cells are generated and you can proceed while reviewing changes with Keep / Undo.
In sample_analysis.ipynb, please create and execute a cell that aggregates monthly sales totals from the SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.ORDERS table using Snowpark and converts it to a pandas DataFrame.
Automations
Saved prompts that run on a schedule. A new chat session is started each time they run, and a desktop notification is delivered upon completion.
From the Automations view, create a new automation by setting a title, prompt, and frequency with New automation, and run it immediately with Run now.
I configured content to append to a log file. Settings such as execution frequency are available.
Let's run it immediately with Run now.
Note: If the automation reaches a tool execution that requires approval, the Automation run stops waiting for approval. It is recommended to run it once with
Run nowfirst to approve the required tool execution permissions if you want scheduled runs to complete unattended.
Note: Automations run when CoCo Desktop is running and the PC is not in sleep mode. If the app is closed at the scheduled time, the run is skipped; however, when the app is opened again, only the most recent missed run per Automation is automatically executed as a catch-up run (older missed runs are discarded). Definitions are saved locally per machine / OS user and are not synced; the execution history limit is 50 entries.
Agentic Browser
The agent can operate the browser built into CoCo Desktop to browse the web and run tests for local applications. Chromium Developer Tools are also available for manual inspection.
dbt integration
Automatically activated upon detecting a dbt_project.yml in the workspace, with lineage visualization, compiled SQL preview, data preview, and a command bar available from the DBT tab. There are two execution modes: Local mode (default), which uses the local dbt CLI, and Snowflake-managed mode.
dbt docs
Note: In Snowflake-managed mode, the Preview tab as well as the Command bar and Build / Compile / Show quick actions are not available (dbt commands are run from the Run button and execution popover). While a local dbt CLI is not required, a
profiles.ymldirectly under the project folder, an enabled Personal Database, and a valid Snowflake connection are necessary. Also, the dbt project synced to the Snowflake workspace has a limit of 20,000 files, includingtarget/anddbt_packages/.
Building apps
Supporting two frameworks, Streamlit in Snowflake and Snowflake App Runtime, the agent assists with everything from scaffolding to iterating with a local development server to deploying to Snowflake. Snowflake CLI 3.19 or higher is required for deployment.
Clicking Build an app launches the agent as shown below, allowing you to develop apps in natural language.
Checking Operational and Governance Features
These are features worth knowing if you are considering production deployment at GA.
Checking usage history (CORTEX_CODE_DESKTOP_USAGE_HISTORY view)
A usage history view dedicated to CoCo Desktop is available in the SNOWFLAKE.ACCOUNT_USAGE schema. It allows you to check credit usage per user and per request for the past 365 days, and the TOKENS_GRANULAR / CREDITS_GRANULAR columns even show a breakdown by model (input / cache_read_input / cache_write_input / output).
-- Credit consumption by user over the last 30 days
SELECT USER_ID, USER_NAME, SUM(TOKEN_CREDITS) AS TOTAL_CREDITS
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_CODE_DESKTOP_USAGE_HISTORY
WHERE USAGE_TIME >= DATEADD('day', -30, CURRENT_TIMESTAMP())
GROUP BY USER_ID, USER_NAME
ORDER BY TOTAL_CREDITS DESC;
Note: This view only includes CoCo Desktop requests; usage from CoCo CLI or CoCo in Snowsight is not included.
Daily credit limit (CORTEX_CODE_DESKTOP_DAILY_EST_CREDIT_LIMIT_PER_USER)
A parameter that allows you to set a daily credit consumption limit per user. The default is -1 (unlimited), and setting it to 0 completely blocks access. Setting a positive value blocks access once the estimated rolling 24-hour usage exceeds the threshold.
-- Check the current setting value
SHOW PARAMETERS LIKE 'CORTEX_CODE_DESKTOP%' IN ACCOUNT;
-- Set a limit at the user level (takes precedence over account level)
ALTER USER coco_test_user SET CORTEX_CODE_DESKTOP_DAILY_EST_CREDIT_LIMIT_PER_USER = 0;
After reaching the limit, an error message is displayed in CoCo Desktop indicating that the daily credit limit has been reached, and the user cannot use it until the estimated rolling 24-hour usage drops below the threshold.
-- Remove the setting
ALTER USER coco_test_user UNSET CORTEX_CODE_DESKTOP_DAILY_EST_CREDIT_LIMIT_PER_USER;
Note: Setting
0at the account level blocks all users. An operational pattern of "setting0at the account level and setting a positive value at the user level only for permitted users" is also possible.
Permission modes
The approval behavior when executing tools can be switched between two modes.
| Mode | Behavior |
|---|---|
| Default Approvals (recommended) | Displays a confirmation prompt before new or high-risk tool calls (bash / MCP / SQL, etc.), editing protected files, and URL access |
| Bypass Approvals | Skips normal approvals including terminal execution, file editing, MCP tools, and SQL execution. Limited to trusted contexts |
Switch using the approval mode picker in the lower left of the chat input field. Note that this setting applies to the entire machine (all projects on the same machine).
Note: Even with Bypass Approvals, code execution in the browser (
browser_evaluate/browser_run_code), clipboard reading (browser_read_clipboard), and launching sub-agents always require confirmation. Conversely, all other operations, including destructive commands, are executed without confirmation, so please limit use to trusted inputs and workspaces.
Operational recommendation: Normally use Default Approvals as the standard, and limit Bypass Approvals to isolated test workspaces or repetitive tasks whose content you fully understand. The official documentation also recommends using the agent terminal sandbox (Agent terminal sandbox) as an additional layer of defense.
Managed settings (Centralized management for organizations)
A mechanism for administrators to enforce organizational policies via a JSON file. It is designed for distribution via device management tools such as Jamf or Intune.
| OS | Placement path |
|---|---|
| macOS | /Library/Application Support/Cortex/managed-settings.json |
| Windows | C:\ProgramData\Cortex\managed-settings.json |
For example, the following configuration rejects dangerous commands and remote skills, disables Bypass Approvals, prohibits persistence of conversation history, and displays an organizational banner.
{
"version": "1.0",
"permissions": {
"deny": ["bash(rm:*)", "bash(curl:*)", "bash(wget:*)", "skill(remote:*)"],
"defaultMode": "allow",
"dangerouslyAllowAll": false
},
"settings": {
"forceNoHistoryMode": true
},
"ui": {
"showManagedBanner": true,
"bannerText": "Managed by your organization.",
"hideDangerousOptions": true
}
}
Setting permissions.dangerouslyAllowAll to false allows you to block Bypass Approvals across the entire organization. When verified on an actual device, the Bypass Approvals option in the approval mode picker was grayed out and displayed "Disabled by admin policy," making it unselectable.
Note: If the
versionfield is missing or invalid, the app starts in fail-closed (restricted mode). Users cannot disable administrator settings.
Conclusion
In conjunction with the GA of CoCo Desktop, I verified the new features since the Preview period and the operational/governance features. In addition to improvements to the development experience such as Memory and semantic code search, I feel that the key point of GA is that the governance features necessary for organizational deployment — usage history view, credit limits, and Managed settings — have come together.
I hope this article is helpful in some way!
