From a command-line request to governed engineering work in one Cortex experience
The terminal is where modern software work becomes real.
It is where developers explore repositories, run builds, investigate failures, review changes, manage environments, automate delivery, and turn an idea into working software. It is fast, expressive, and deeply connected to the tools engineering teams use every day.
Yet most AI experiences still treat the terminal as an endpoint. A user moves a question into a separate chat, copies the answer back into a shell, reconstructs the project context, runs the suggested commands, and then explains the result to the AI again. The user becomes the bridge between conversation and execution.
Cortex CLI changes that relationship.
Cortex CLI brings the Cortex Enterprise AI experience directly into the command line. Developers can describe an objective in natural language, work interactively with Cortex, review proposed actions, and carry eligible tasks through implementation, validation, and completion without leaving the environment where the project already lives.
This is not a separate terminal assistant with a separate identity. It is Cortex in the terminal: the same connected experience, coordinated intelligence, governed workflows, and user control already available across the broader Cortex platform.
With Cortex CLI, Cortex now spans twelve user-facing platforms and product surfaces:
- Five browser extensions: Google Chrome, Apple Safari, Microsoft Edge, Mozilla Firefox, and Brave
- Three IDEs: Microsoft Visual Studio Code, Microsoft Visual Studio, and JetBrains IntelliJ IDEA
- Two mobile platforms: Android and iPhone
- The purpose-built Cortex Discover Agentic AI browser
- The new Cortex CLI for the terminal
Twelve platforms. One Cortex account. One connected experience. One path from intent to reviewable results.
The next step in the Cortex story
Cortex has expanded around a consistent idea: enterprise AI should meet people where work happens while preserving continuity, control, and context.
Cortex Connect allowed an objective to move across devices and work surfaces without becoming a disconnected series of prompts. The three Cortex Routers brought together the right intelligence, current public information, and relevant expertise behind one simple experience. Cortex Cloud added durable managed execution for eligible work. Cortex Discover made the browser a first-class agentic environment. More recent releases added collections, chat forks, governed workflows, validation, runtime security, and reusable inference designed for faster, trusted AI experiences.
Cortex CLI adds the terminal to that connected control layer.
The progression is straightforward:
- Cortex Connect keeps the objective, progress, and result connected across work surfaces.
- Cortex Routers coordinate the intelligence, information, and expertise appropriate to the request.
- Cortex Planner and governed workflows organize larger objectives into understandable work.
- Cortex Cloud provides a durable managed destination for eligible execution and validation.
- Cortex Discover brings current web context and controlled browser action into Cortex.
- Cortex CLI brings Cortex to local terminals, remote shells, automation, and the command-line workflows developers already trust.
Each environment contributes something different. Together, they form one enterprise AI platform rather than a collection of isolated assistants.
Why the terminal needs a first-class Cortex experience
For developers, the terminal is not merely a place to type commands. It is a compact interface to the entire software lifecycle.
A single session may move from understanding a repository to reproducing a defect, updating code, running tests, reviewing a patch, checking security implications, and preparing a result for the rest of the team. The work is connected even when the tools are not.
Traditional AI chat interrupts that flow. It often lacks the current workspace, cannot follow the result of a command, and loses the relationship between a recommendation and what actually happened. A suggested fix may sound convincing while the build remains broken. A generated command may be technically valid but inappropriate for the project. A long task may disappear when the terminal closes or the network changes.
Cortex CLI treats the terminal as an active Cortex work surface.
It keeps the conversation close to the repository and the developer’s normal tools. It can help investigate, explain, implement, test, review, and validate within a continuous workflow. It reports progress where the work is happening and keeps consequential actions visible to the user.
The value is not automation for its own sake. The value is reducing the distance between an engineering objective and a trustworthy outcome.
Natural-language engineering without leaving the command line
Cortex CLI gives developers a direct way to work with Cortex from the terminal.
A developer can ask Cortex to understand an unfamiliar project, diagnose a failing test, prepare a focused change, review a patch, research current documentation, or validate whether completed work satisfies the original objective. The interaction can remain conversational for exploratory work or become more structured when the task calls for a defined result.
The terminal experience adapts to the way developers work. It supports a rich interactive workspace for focused sessions and a streamlined conversational mode for ordinary shells, remote environments, and simpler command-line use. Conversations, attachments, project context, model choices, task status, changes, and approvals stay within a consistent Cortex interaction.
The user does not need to translate an objective into a catalog of low-level AI operations. Cortex coordinates the relevant capabilities behind the request while keeping the meaningful decisions visible.
That produces a simpler pattern:
- Describe the outcome in natural language.
- Let Cortex understand the workspace and organize the work.
- Review actions when they affect the project or environment.
- Follow progress as implementation and validation proceed.
- Inspect the result and continue from the same Cortex conversation.
The command line remains familiar. Cortex makes it connected.
Interactive work and automation through one product
Engineering work does not happen only in an interactive terminal.
The same kinds of tasks also appear in continuous integration, remote development environments, containers, scheduled jobs, and team automation. A useful enterprise CLI must support both a person working at a prompt and a system expecting a dependable outcome.
Cortex CLI is designed for both.
In an interactive session, developers can collaborate with Cortex, inspect progress, provide direction, and approve important actions. In automated environments, teams can request bounded work and receive stable, machine-readable results suitable for the surrounding workflow. Non-interactive operation remains explicit: if a task reaches a decision that requires human approval, it does not quietly invent permission.
This creates a consistent product boundary across local development and engineering automation. Teams can use the same Cortex experience for an investigation at a laptop, a review in a remote shell, or an eligible validation task in a delivery workflow without treating each environment as a different AI product.
For organizations, that consistency matters. It reduces one-off scripts, fragmented assistant behavior, and separate governance models for interactive and automated work.
From a terminal session to a durable workflow
Useful engineering tasks rarely fit into one prompt or one uninterrupted connection.
A migration may require investigation, planning, implementation, testing, review, and follow-up. A failure may reveal another dependency. A developer may need to pause for an approval, close a laptop, reconnect through a remote shell, or continue from another Cortex surface.
Cortex CLI participates in the durable workflow foundation of Cortex. Sessions can be resumed, progress can remain visible, and eligible work can continue through meaningful stages without forcing the user to reconstruct the objective after every interruption.
This fits directly with the recent introduction of Chat Collections, Forks, and Governed Workflows. Collections help users keep related conversations organized. Forks make it possible to explore another direction without losing the original line of thought. Governed workflows carry an approved objective through investigation, implementation, testing, review, and verification.
Cortex CLI gives those workflows a natural terminal surface.
A developer can continue a conversation in the terminal, return to an existing task, inspect what remains, provide a decision, or review the result close to the affected project. The conversation expresses intent. The workflow preserves progress, evidence, and outstanding decisions. The terminal becomes another connected view of the same work.
Continuity here is more than saved chat history. It is continuity of objective, continuity of progress, and continuity of control.
One objective across Discover, browsers, IDEs, mobile, and CLI
Cortex CLI is most powerful as part of the larger Cortex experience.
Consider a developer planning a framework upgrade:
- The work begins in Cortex Discover while the developer reads current documentation and compares release guidance across several tabs.
- Search Routing brings current public information into the investigation.
- The developer continues the objective in an IDE or opens Cortex CLI in the relevant repository.
- Cortex helps assess the project, prepare the change, and run the appropriate validation.
- Progress remains available through Cortex Connect, including from mobile when the developer steps away.
- If the task benefits from durable managed execution, the user can move eligible work to Cortex Cloud.
- The result returns through the same connected Cortex workflow for review.
Or consider a production issue:
- An alert is reviewed in a supported browser or Cortex Discover.
- A team member starts the investigation from mobile while away from a workstation.
- The objective continues in Cortex CLI on an approved operational or development environment.
- Cortex helps inspect the relevant project evidence and prepare a bounded response.
- Security-focused intelligence and workflow controls remain part of the task.
- The final result is visible across the connected Cortex experience.
The user should not have to decide which AI owns each step. Cortex maintains the objective while each work surface contributes the context and capabilities appropriate to its role.
This is what one platform, one experience means in practice: not the same screen everywhere, but the same work moving coherently across the places where people research, build, review, and decide.
Coordinated Cortex intelligence at the terminal
Cortex CLI is not an isolated command-line model.
It participates in the broader Cortex AI Model Ensemble and the three Cortex Routers:
- Model Routing helps connect the request with the appropriate Cortex intelligence.
- Search Routing brings current public information into the workflow when freshness matters.
- Skill Routing applies relevant engineering, testing, security, and verification practices.
This coordination is especially valuable in the terminal, where different requests may look similar on the surface but require very different treatment. Explaining a configuration file, implementing a feature, investigating a new vulnerability, reviewing a change, and validating a release are not the same task. They should not all be handled as generic text generation.
The developer states the objective. Cortex coordinates the specialization underneath.
Recent work on the Cortex inference cache architecture strengthens this experience for ongoing and repeated work. Cortex can reduce unnecessary repetition where the context, permissions, and request remain eligible, while treating freshness and access as requirements rather than afterthoughts. The result is a product designed to feel responsive across long-running conversations without confusing speed with correctness.
Local execution or Cortex Cloud, with the user in control
Some engineering work belongs on the developer’s machine. Other work benefits from a durable, managed environment.
Cortex CLI supports that distinction as part of the wider Cortex platform. Local work stays close to the repository, tools, and environment the developer is already using. Eligible tasks can also participate in Cortex Cloud when the workflow benefits from managed execution, continuity beyond one device, or broader validation.
The choice does not create a second conversation. The objective, progress, and result remain part of Cortex.
Recent Cortex Cloud releases extended managed execution with connected validation and runtime security. Eligible software work can move beyond producing a patch toward producing reviewable evidence about what was assessed, tested, and observed. Cortex CLI gives developers and automation systems a direct route into that larger workflow while keeping the result close to everyday engineering practice.
The important boundary remains clear: choosing cloud execution does not remove user control, and local terminal access does not imply unrestricted authority elsewhere. Each environment contributes scoped capabilities suited to its role.
Governed action instead of an unrestricted shell agent
An AI that can participate in terminal work must be useful without becoming invisible.
Cortex CLI is designed around explicit control. Reading project context is different from changing a file. Preparing a command is different from running it. Running a test is different from publishing a release, changing infrastructure, or performing another consequential action.
The product keeps those distinctions visible.
Developers can review proposed project changes and command-line actions before they affect the workspace. Organizational and project guidance can shape the task, but repository content does not automatically grant itself authority. Sensitive credentials remain under established system and Cortex controls. When a workflow reaches a point that needs approval, the user remains part of the decision.
This supports a practical division of responsibility:
- Cortex can understand the objective and prepare the work.
- Cortex Safety and organizational policy can evaluate relevant boundaries.
- The CLI can present actions and outcomes in the environment where they occur.
- The user can approve, reject, redirect, or stop consequential work.
Human control is not separate from the agentic experience. It is what makes meaningful agentic work appropriate for the enterprise.
Completion grounded in evidence
Generating a plausible response is not the same as completing an engineering task.
A change is not finished merely because code was written. A defect is not resolved merely because a patch looks reasonable. A review is not complete merely because an AI produced a confident summary.
Cortex CLI keeps the requested outcome connected to the work used to establish it. Tests, checks, diffs, project state, and workflow results can contribute to a reviewable conclusion. When validation fails or the environment changes, Cortex can report that state instead of presenting optimistic completion.
This aligns with the larger Cortex movement from chat to verified work. Recent governed workflow capabilities make completion depend on evidence and review. Cortex Cloud extends that principle into managed validation and runtime security. Cortex CLI brings it into the developer’s immediate working environment.
For users, this means less time translating between an assistant’s claim and the actual state of the project. For enterprises, it creates a clearer basis for review, accountability, and repeatable software delivery.
The goal is not simply faster code generation. It is a shorter, safer path from intent to an outcome teams can inspect and trust.
Built for real enterprise environments
Enterprise development happens across different operating systems, network conditions, security policies, and deployment models. A command-line product must fit those realities without turning every developer into an AI platform operator.
Cortex CLI is available for macOS, Windows, and Linux, with familiar installation paths for individual developers and organizations. It supports ordinary interactive terminals, remote and constrained environments, and automated use cases. It is designed to behave predictably when connectivity changes and to work with common enterprise network requirements.
Operational visibility is similarly bounded. Reliability information can help teams understand product health without making prompts, source code, or response content part of routine telemetry. Product updates and distribution follow the same emphasis on trusted software identity and release discipline that organizations expect from enterprise tooling.
The result is a Cortex experience that feels native to the terminal while remaining connected to the governance and reliability of the larger platform.
What Cortex CLI changes for engineering teams
The immediate benefit is flow: fewer context switches, less copying between a chat and a shell, and a more direct path from a request to project-aware work.
The larger benefit is structural.
Cortex CLI connects the command line to the enterprise AI control layer already spanning browsers, IDEs, mobile, Cortex Discover, and Cortex Cloud. That connection gives teams:
- A consistent Cortex experience in the terminal
- Natural-language access to coding, investigation, review, research, testing, and validation workflows
- Continuity across interactive sessions, devices, and work surfaces
- A shared path for local and eligible managed cloud execution
- Coordinated model, search, and skill routing behind one interface
- Visible approvals for consequential local actions
- Reviewable progress and evidence for longer-running work
- A dependable interface for both developers and engineering automation
- Cross-platform availability for macOS, Windows, and Linux
These benefits reinforce one another. Speed without context creates rework. Action without control creates risk. Continuity without freshness creates confident mistakes. Automation without evidence creates uncertain outcomes.
Cortex CLI brings the pieces together around the engineering objective.
One Cortex, wherever work happens
Cortex began by bringing intelligent coding and security assistance into the developer environment. It has since grown into a connected Enterprise AI platform spanning specialized intelligence, browsers, IDEs, mobile devices, managed cloud execution, an Agentic AI browser, and now the command line.
Cortex CLI is the twelfth Cortex platform and product surface, but the larger story is not the number.
The larger story is continuity.
A question can begin on a phone. Research can continue in a browser. Current web context can become a project objective in Cortex Discover. Implementation can move into an IDE or the terminal. Longer work can continue through Cortex Cloud. Progress, approvals, evidence, and results can remain part of one Cortex experience throughout.
The interface changes because the work changes. The objective does not have to.
That is the direction of Cortex: one platform that brings coordinated intelligence to every major work surface; one experience that follows the user without fragmenting the task; and one governed path from intent, to action, to a result that can be reviewed.
Cortex CLI brings that experience home to the terminal.
