Skip to main content
Cortex Code is a coding agent, not a chat with a different icon. You point it at one repository, describe the change in plain language, and it works through the task inside an isolated runtime: reading files, editing them, running your build and your tests, while a timeline records what it did. You decide how much a turn may do on its own, and no file lands in the tree until a human approves it. Code is a mode of your Cortex account rather than a separate product. It runs in your browser, in the Cortex desktop app and in the Cortex CLI. This page says what Code is and is not, links every page in this tab, and marks the line where Code stops and Cortex Security or the CLI begins.

​
What Code is

​
Who can open it

Code is a member surface. A guest who visits the Code area sees the public product page, and a guest on a deep link sees This space is reserved, with Continue in Chat or Sign in. Once you are signed in, Code Home is the composer itself. Its heading reads What should Cortex build? and its prompt box reads Ask Cortex to build, fix, explore. A guest can type there, but pressing Start session opens the sign-in dialog. That is an invitation, not an error.
The first-run Cortex Code home on macOS with a task composer, repository chooser, and GitHub connection prompt.
The first-run Cortex Code home on macOS with a task composer, repository chooser, and GitHub connection prompt.

Interface preview

​
Start here

Code quickstart

Sign in, connect GitHub, run a first Cloud session and approve the change it proposes.

How Code works

The turn loop in user terms: where tools run, what each mode withholds, how a turn ends.

​
Work in a session

Code sessions

The session object, the board, the transcript, follow-ups and what survives a turn.

Ask, Plan, Agent

The three interaction modes, what each may reach, and switching per turn.

Permissions and approvals

Allow once, Always allow and Deny for commands, plus the separate gate on file writes.

Changes and diffs

The Changes pane, a proposed diff before a write and a landed diff after it.

Tickets

Tickets as a unit of asynchronous work, and why they have no screen in the app yet.

​
Where code runs

Cloud runtimes

The isolated Cloud guest a session attaches, how it is prepared, and what happens without capacity.

Environments and images

Running machines and saved images, so the next session on a repository skips the install.

Machines

Cloud occupancy and team runners, and why desktop hosts are not offered in the browser.

SSH hosts

Register a remote host in the desktop app, then select it for a session from there or from the CLI.

Code on desktop

This PC and SSH exist in the desktop app and the CLI. The browser stays on Cloud.

​
Repositories

Connect GitHub

One control, no tokens to paste, and what to do when a connection lapses.

Repositories and branches

Pick the repository and the base branch, and work in the session’s own isolated worktree.

​
Automate and monitor

Automations

Saved instructions with a trigger, a repository and a prompt, and what a run does today.

Code notifications

The inbox that tells you when a session finished or needs a decision.

Usage

Recorded cost and billable actions over a 7, 30 or 90 day window.

​
Configure

Code settings

Default model and fallback models, and the settings that are not configurable yet.

Code integrations

Connected apps, repositories and tool servers for the workspace.

​
Reference

Code in the terminal

The same sessions from a terminal, and how CLI words map onto Code words.

Pull-request review

Where Cortex Security sits under Code, and which tab documents it.

Code troubleshooting

Gates that will not open, a runtime that is unavailable, and modes that will not edit.

​
Where a session runs

Everything a turn does happens inside the runtime it attached. Nothing runs in your browser.

​
Modes in one line

Ask answers questions and reads files. Plan writes a reviewable plan. Agent edits files, runs commands and opens a pull request. The choice is a lock on the tools the turn is built with, so a change applies to the next turn, not to the turn already running. The composer’s fourth row, Security, is not a fourth mode: it leaves for Cortex Security. See Ask, Plan, Agent.

​
Two gates, and they are not the same

A command that needs a decision raises a card above the transcript with Allow once, Always allow and Deny. A file write never uses that card: it waits in the Changes pane for a human Approve, per file or as Approve all, and a session-level Always allow never covers a write.
There is no undo, no checkpoint and no revert anywhere in Code. The moment to refuse a change is while it is still pending in Changes, with Reject. See Permissions and approvals.

​
What Code is not

  • Not a hosted development environment. There is no screen in a Code runtime.
  • Not a place to store secrets. Code has no Secrets page and never asks you to paste a token.
  • Not a continuous integration system. It runs your commands in a session, on request.
  • Not a chat about your code. It edits the repository and opens pull requests.

​
Not available yet

  • Tickets have no screen in the app; they are an API level concept today.
  • A session’s Desktop tab is drawn with the badge Soon.
  • Automations are saved instructions only: Schedules and events do not execute yet.
  • A Code session has no tool servers, connectors or plugins of its own, so do not plan work around attaching one to a session. See Code integrations.

​
How it fits with the other products

  • Cortex Chat shares the account and the sidebar. Chat talks about your code; Code changes it. See Cortex Chat.
  • The Cortex CLI drives the same sessions from a terminal, and a session it started is marked · Started from CLI on the board. See Code in the terminal and Cortex CLI.
  • Cortex Security reads a pull request and posts a review; it lives under Code in the app and is documented in its own tab. See Pull-request review and Cortex Security.