Pulse, long-horizon execution, multi-agent worktrees, browser-powered development in VS Code, and response modes bring a new level of continuity to the Cortex experience
The most valuable work rarely begins and ends in a single prompt.
A software release may start with a question, expand into research, require changes across several parts of a repository, move through testing and security review, wait for a pull request or CI run, and return to a person for a final decision. A business workflow may depend on a recurring briefing, a changing source, a scheduled action, and an approval that arrives hours later.
Traditional AI experiences are organized around the moment of interaction. The user asks, the AI responds, and the session waits for another prompt. That pattern is useful, but it leaves people responsible for much of the work around the answer: remembering what needs attention, restarting tasks, moving context between tools, coordinating parallel efforts, checking whether changes worked, and deciding when a result is truly complete.
Cortex is moving beyond that boundary.
The latest Cortex innovations are built around a broader idea: Enterprise AI should remain connected to an objective for as long as the work requires. It should notice relevant change, coordinate specialized effort, operate in the right environment, preserve progress through interruptions, and return with evidence that people can review.
Cortex Pulse, Workflow Recipes and Automations, multi-agent worktree orchestration, the VS Code Integrated Browser, long-horizon work, and the new Fast, Balanced, and Deep response modes all support that direction. Recent interface improvements bring these capabilities into a clearer daily experience through briefings, Inbox cards, schedules, workflow status, approvals, collections, chat forks, browser evidence, and visible progress.
Together, they advance Cortex from an AI product that helps in individual moments to an Enterprise AI Control Layer that can help keep meaningful work moving.
The next step in the Cortex journey
Cortex has expanded through a consistent sequence.
The Cortex AI Model Ensemble introduced specialized intelligence for coding, security, safety, validation, planning, and routing. Cortex Router connected a user objective with the right models, current information, and engineering practices. Cortex Planner gave larger requests a structured path through investigation, implementation, testing, review, and verification.
Cortex Connect allowed work to move across browser, mobile, and Visual Studio Code without losing its objective. Cortex Cloud added durable managed execution. Cortex Discover made the browser a first-class environment for current context, multi-tab reasoning, and governed web action. Collections, chat forks, and governed workflows then made it easier to organize ideas, explore alternatives, and carry a chosen direction into reviewable work.
The latest release connects those foundations over a longer span of time.
Cortex can now support work before the user opens a conversation, during active execution, across parallel engineering streams, inside a running application, and after the original session has ended. The experience is becoming continuous without becoming uncontrolled. Users retain clear authority over what Cortex watches, what it may prepare, which actions need approval, what resources a workflow can use, and when work should stop.
This is an important distinction for enterprise adoption. Organizations do not need an AI system that is simply active more often. They need one that understands the lifecycle of work and participates within defined boundaries.
Cortex Pulse keeps important work in view
Many valuable tasks begin with a change rather than a prompt.
A build fails overnight. A pull request receives a review. A repository has a new commit. A dependency publishes a security advisory. A customer account changes state. A scheduled report becomes available. A project reaches a deadline. By the time a person asks an AI assistant what happened, the first challenge is already finding, collecting, and prioritizing the right information.
Cortex Pulse introduces a persistent, proactive Cortex experience organized around a user’s goals.
Pulse can watch approved sources, identify relevant changes, prepare concise briefings, and bring opportunities, approvals, completions, and failures into one visible flow. Instead of requiring the user to repeatedly revisit the same systems and reconstruct the same request, Pulse maintains the relationship among the goal, the source, the triggering event, and the next useful step.
The center of the experience is a focused Today view. It shows what changed, what is in progress, what needs attention, and what has completed. A visible status communicates whether Pulse is healthy, working, paused, restricted, or waiting for the user. The Inbox provides a durable place for briefing cards, questions, approvals, results, and failures, with controls to acknowledge, snooze, dismiss, or provide feedback.
This changes the daily rhythm of Enterprise AI. A user no longer needs to begin every morning by asking a series of systems for updates. Pulse can assemble a goal-aware view of the work that deserves attention, then let the user decide what should happen next.
For engineering teams, Pulse can follow repository activity across one or several approved projects. It can surface current commits, open pull requests, recent CI activity, and conditions that need review. In Visual Studio Code, repository-related Pulse cards stay close to the project, while broader configuration and history remain available in the primary Cortex interface. On mobile, the same experience can support briefing review, approvals, pause, snooze, and emergency stop when the user is away from a desk.
Pulse is designed around earned authority. A connection provides visibility within its approved scope. It does not silently become permission to act. Watches define what Pulse should monitor. Rules define what it may prepare, propose, or perform. Budgets, quiet hours, notification policies, retention controls, and a global pause keep the experience understandable.
Always available does not mean always running. Pulse operates within user-defined schedules, priorities, and limits, helping teams stay informed without creating unnecessary noise or activity.
The result is a practical form of proactive AI: relevant work reaches the user with context, evidence, and a clear next decision.
Workflow Recipes turn successful work into repeatable capability
Some work begins as a one-time request and quickly becomes a pattern.
A team may regularly review release readiness, summarize repository health, investigate a class of incidents, compare a changing set of sources, prepare an upgrade assessment, or validate that a recurring process completed correctly. Rewriting the prompt each time creates inconsistency. Traditional automation can remove repetition, but it often requires a separate builder, brittle scripts, and ongoing maintenance far removed from the people who understand the goal.
Workflow Recipes give Cortex a more natural path from successful work to repeatable work.
A recipe captures the useful pattern behind reviewed work, including the decisions and evidence that made the result trustworthy. Teams can reuse that pattern, adapt it to another approved project, or connect it to a schedule through Cortex Automations.
This makes automation a continuation of the Cortex experience. The user begins with an objective in natural language. Cortex helps organize and complete the work. Once the process is understood and reviewed, the useful structure can become a recipe instead of disappearing into a conversation history.
Automations provide the durable timing layer. A user can choose the project or source, define the task, set a cadence and time zone, preview upcoming runs, select the execution environment, establish budgets, and decide how missed runs or failures should be handled. Manual Run now controls make schedules useful for immediate work as well as recurring execution.
Pulse adds the surrounding context that ordinary schedulers lack. A scheduled run can remain connected to a goal, a watch, an evidence workspace, and the Inbox. Results arrive as part of the same product experience, with their source, status, approvals, and next action visible. Material changes can be highlighted while routine healthy runs can be bundled into a concise briefing.
Consider a weekly release-readiness recipe. Cortex can inspect approved repository evidence, review pull requests and CI state, identify unresolved risks, prepare a concise report, and place any required decision in the Inbox. If a prepared fix is appropriate, the workflow can move into an isolated engineering environment and wait for the required approval. The schedule starts the work, but governance defines what it may do.
Workflow Recipes create leverage from processes that teams already trust. They allow good work to become repeatable without turning every user into an automation engineer.
Multi-agent orchestration becomes safer through worktree isolation
Complex engineering requests benefit from specialization and parallelism.
A broad change may require one specialist to understand an unfamiliar area of the codebase, another to implement a focused update, another to design tests, and another to assess security or verify the final result. Some activities depend on earlier findings. Others can proceed at the same time. The challenge is bringing those contributions together without creating overlapping edits, hidden conflicts, or an unreviewable final state.
Cortex now combines multi-agent orchestration with isolated Git worktrees.
The work begins with a shared objective and clear boundaries. Cortex coordinates specialized efforts around the parts of the task that can move forward together, while preserving the dependencies and review points that keep the overall result coherent.
Worktree isolation gives each effort a protected place to develop and validate changes without disrupting the developer’s active workspace. Contributions remain reviewable before they become part of the combined result.
The business impact is larger than faster code generation.
Parallelism becomes useful when teams can trust how the work comes together. Cortex keeps progress visible, surfaces conflicts and changing conditions, and preserves human review at the moments that matter. Teams gain the speed of coordinated effort without turning the development process into a black box.
This model also gives multi-agent work a clearer meaning. Agents are not simply producing several answers to the same prompt. They are contributing bounded work to a coordinated objective, with dependencies, permissions, and evidence connecting each contribution to the final result.
For a cross-cutting product change, Cortex can coordinate investigation, implementation, testing, and security review across focused streams of work. Teams can review the combined outcome with the context and evidence needed to understand what changed and why.
This is how Enterprise AI can scale engineering effort without sacrificing the practices that make software delivery dependable.
The browser becomes a development surface inside Visual Studio Code
Software does not live only in source files.
Developers move constantly among code, repositories, pull requests, documentation, dashboards, security tools, consoles, and running applications. The browser is where much of that work is understood, coordinated, and completed. Treating it only as a final verification step leaves a large part of the development lifecycle disconnected.
The Cortex VS Code Browser brings that broader browser work directly into the development environment.
This direction was shaped by early design partners who tried Cortex and asked for browser capabilities inside the developer tools they already use. Their feedback reinforced a practical point: developers gain more value when AI works naturally with established tools and workflows. The VS Code Browser responds to that need and deepens how Cortex works alongside widely used developer tools such as Microsoft Visual Studio Code.
Cortex can use the browser to research an issue, navigate code and repository context, review pull requests, follow build and test results, work with development dashboards, inspect a running application, and gather current evidence. With the appropriate permissions and approvals, it can also help open or update a pull request, initiate supported checks or scans, and follow the result back into the development workflow.
That creates a more complete loop between understanding, action, and validation. A developer can begin with a pull request, an alert, a visible application issue, or a question about unfamiliar code. Cortex can connect what it finds in the browser with the repository and development tools in the same session, help move the work forward, and return with evidence that is relevant to the original objective.
This is especially valuable for work that crosses boundaries. A security finding may lead to code investigation and a prepared fix. A pull request may lead to a scan, review feedback, and further changes. A rendered issue may lead back to its source and then forward again to the updated application. The browser is not merely where Cortex checks the answer. It is an active surface where development work can progress.
The Integrated Browser also connects current web evidence with the broader Cortex agent and connector experience. Approved pages can inform work across the services and workspaces a team already uses, without creating a separate browser-only workflow. Existing permissions, safety controls, and approval requirements continue to govern external systems.
Browser access remains under user and organizational control. Sharing, workspace policies, permissions, and approvals define where Cortex can work and which actions require a person’s decision.
The key outcome is a less fragmented development experience. Research, repository work, pull requests, scans, application interaction, and verification can remain connected to the same objective instead of being split across an editor, browser windows, screenshots, and separate conversations.
Cortex Discover remains the purpose-built Agentic AI browser for broader enterprise web work. The VS Code Browser serves a complementary role: it makes browser-powered development part of the workflow inside Visual Studio Code.
Long-horizon work keeps the objective intact
Some tasks take minutes. Others need an afternoon, an overnight run, or several rounds of human review.
Longer work introduces problems that short chat interactions can avoid. Processes restart. Connections drop. dependencies change. A specialist fails after others have completed. An approval arrives later. A validation step reveals that part of the plan needs repair. A deployment succeeds while the final notification is interrupted. Simply replaying the workflow can waste effort or repeat a consequential action.
Cortex long-horizon work is designed for this reality.
A long-running objective remains connected to its progress, decisions, evidence, and current status across interruptions. Cortex can continue from a trusted point, preserve useful work, and bring uncertain or consequential outcomes back to a person for review.
This continuity can carry an objective from discovery and planning through implementation, browser-enabled development, validation, and delivery. The experience remains connected even as the work moves across tools, specialists, and review points.
This matters because context is more than conversation history. Cortex keeps the decisions, progress, validation, and outstanding approvals around an objective connected, so users do not have to reconstruct the work after every pause.
Completion also gains a stronger definition. Cortex connects the final result with current evidence and makes unfinished checks or decisions visible, giving teams a clearer basis for deciding when the work is truly done.
Long-horizon execution turns continuity into an operational capability. Teams can assign more meaningful objectives while retaining visibility into how the work is progressing, what has been verified, and where a person is still needed.
Fast, Balanced, and Deep put effort in the user’s hands
The same level of reasoning is not appropriate for every request.
A quick question should feel immediate. Everyday development and research need a practical balance of speed and depth. A difficult investigation, architecture decision, or long-horizon objective may justify more reasoning and broader context.
Cortex now gives users three clear response modes: Fast, Balanced, and Deep.
Fast is designed for responsiveness. It is well suited to direct questions, quick explanations, concise transformations, and lightweight work where delay would add more friction than value.
Balanced is the default for everyday Cortex use. It provides a strong middle ground for coding, research, analysis, and normal workflow decisions.
Deep gives complex work more room. It can apply greater reasoning effort and, where the user’s plan and available capacity permit, adapt to extended context for demanding investigations and larger objectives.
The mode selector is consistent across Cortex experiences and travels with the session. Users choose the level of effort in simple product language without managing context-window sizes, provider settings, or internal model configurations. Cortex continues to route the request across appropriate specialized intelligence underneath that preference.
This preserves an important part of the Cortex philosophy. Model choice should give people useful control without exposing the complexity of the model ecosystem. Fast, Balanced, and Deep express the experience the user wants. Cortex handles the underlying coordination, availability, safety, and organizational policy.
For organizations, the modes also create a clearer relationship among urgency, depth, capacity, and cost. Policies can define what is available while keeping the interface understandable for employees. Users can move quickly when the task is simple and invest more effort when the outcome deserves it.
A clearer interface for work that continues
As Cortex becomes more capable, the interface must make ongoing work easier to understand.
Recent experience improvements are centered on continuity rather than adding more controls for their own sake.
Collections give related conversations a durable place. Chat forks let users explore another direction while preserving the original discussion. Pulse Today and Inbox bring proactive updates, approvals, and results into focused views. Schedules connect recurring work to its source, next run, recent outcome, and controls. Task and workflow views show what is running, what has completed, what needs attention, and which decision is blocking progress.
Approval cards present consequential steps in context. Browser artifacts and evidence links connect claims to the pages and rendered results that support them. Repository cards keep project activity close to the code in Visual Studio Code. Mode controls make response depth visible at the composer. Status, pause, resume, run-now, snooze, and emergency-stop controls give users direct ways to shape ongoing work.
These elements are part of one interaction model. A user can begin with a conversation, organize it into a collection, fork an alternative, turn the chosen objective into a workflow, follow its progress, approve a prepared action, and receive the verified result through the same Cortex experience. A successful process can then become a reusable recipe or scheduled automation.
The interface does not ask the user to think like a workflow engine. It presents the decisions that matter and keeps operational detail available when it is useful.
What this changes for teams
The immediate gains are practical: fewer repeated prompts, less copy and paste, fewer context switches, faster feedback between code and the running application, and clearer visibility into work that continues after the user steps away.
The larger gain is organizational.
Teams can begin to treat AI-assisted work as a managed capability rather than a collection of isolated conversations. Useful processes can be repeated. Parallel contributions can be isolated and verified. Long-running objectives can survive interruptions. Browser results can become evidence. Routine monitoring can happen without constant manual checking. Human authority can remain visible at the points where it matters.
Engineering teams can coordinate broader changes without forcing one developer to supervise every small step. Security teams can keep watches on relevant sources and bring findings into governed investigation and remediation. Product teams can connect current application behavior with repository work. Leaders can receive concise briefings and review decisions without living inside every tool used to produce them.
The platform remains grounded in least privilege. Sources are approved. Workspaces and worktrees are scoped. Rules define action authority. Schedules have budgets and limits. Authenticated browser state requires explicit sharing. External changes remain tied to connectors and approvals. Completion depends on evidence.
Capability and control advance together.
From a helpful moment to a durable outcome
Enterprise AI is entering a new phase.
The quality of an answer still matters. So do the moments around it: what caused the work to begin, how the objective was organized, which specialists contributed, where changes occurred, what happened after an interruption, how the result was verified, and who approved the consequential steps.
Cortex now brings those moments into one connected product direction.
Pulse keeps goals and changing work in view. Workflow Recipes and Automations turn trusted processes into repeatable capability. Multi-agent worktrees allow specialized efforts to proceed in parallel with isolation and review. The VS Code Browser connects code, repositories, pull requests, development services, and running applications within the developer workflow. Long-horizon execution preserves progress and evidence across time. Fast, Balanced, and Deep let users match the experience to the task.
The broader message is simple: Cortex is becoming an Enterprise AI system that stays with the work.
It can meet users where an objective appears, coordinate the right intelligence and tools, carry approved work through the environments where it belongs, and return with a result that can be understood and trusted.
That is the path from AI assistance to continuous, coordinated work.
