OpenAI’s GPT-5.6 launch on Thursday was widely expected, but in addition to the new models, the company also made a few other major product announcements, including the launch of ChatGPT Work, its Codex-based agentic tool for knowledge workers that will compete with Claude Cowork.

OpenAI is also collapsing the ChatGPT and Codex desktop apps into a single app, akin to what Anthropic has done with its Claude desktop app, too.

The superapp takes shape

At the core of this is OpenAI’s continuous efforts to build its superapp, and while it originally looked like Codex was going to become that overarching app that integrates all of the OpenAI services, it’s actually the ChatGPT app that is absorbing everything — or at least it’s the branding that OpenAI is choosing to focus on because it looks like this is mostly a rebranding and expansion of the Codex app — not a rebuild of the existing ChatGPT app.

“Codex is now part of a broader ChatGPT desktop app,” an OpenAI spokesperson told The New Stack. “Within the ChatGPT desktop app, ChatGPT Work is for those looking to tackle a broader range of complex projects, bringing Codex’s agentic capabilities across web, mobile, and desktop, while Codex itself remains focused on software development.”

ChatGPT Work

ChatGPT Work is the most important launch here. “With Codex technology built-in, ChatGPT can now move beyond answering questions to getting real work done across web, mobile, and desktop,” OpenAI writes in its announcement and notes that many Codex users were already using it for non-coding tasks.

This is pretty much the exact same pitch Anthropic is making for Claude Cowork as well, and Cowork, too, grew out of the fact that knowledge workers started using Claude Code.

In terms of capabilities, ChatGPT Work is pretty much what you’d expect. It is meant to help kick off complex agentic workflows based on documents, spreadsheets, and other assets — and/or to create them. It can pull in data from third-party services and use tools as necessary, including Slack, Microsoft Teams, Google Drive, SharePoint, calendars, CRM services, and others.

One feature of ChatGPT Work OpenAI stresses is that it is available on the desktop, but also on the web and mobile. Claude Cowork was desktop-bound until only a few days ago, but from the outset, ChatGPT Work users can start tasks on their phone and continue on the web or desktop as needed.

Since the ChatGPT app can access files and apps, though, and has a built-in browser, the desktop will likely be where most users will want to use the tool.

Like Claude Cowork, ChatGPT Work also features the ability to schedule tasks (aptly named ‘Scheduled Tasks’). There is no need to keep a laptop open to run these since they will run in the cloud.

ChatGPT and Codex become one

With this launch, Codex is merging into the ChatGPT desktop app. For developers already used to the Codex app, not much changes with this, OpenAI says. “Codex keeps its dedicated coding experience alongside Chat and Work, with inline editing in diffs, pull request review in the side panel, faster Computer Use powered by GPT-5.6, and multi-repository projects,” the company writes.

If you already have Codex installed, the next update will automatically give you the new app (though with the ability to keep the Codex app icon). Virtually nothing else is changing, it seems.

What is interesting, though, is that the basic chat interface has almost been relegated to a minor feature in the app now. It’s a capability that now sits in the sidebar next to the ability to manage scheduled tasks and plugins. Work and Codex are the two modes users can switch between — chat is not one of them.

Atlas shrugged

The new app still includes the built-in browser, which is especially useful when it comes to browser-use tasks, but OpenAI is also launching a new Chrome extension that brings ChatGPT right into the Chrome sidebar. And that’s also the end of OpenAI’s Atlas browser.

“These capabilities build on what we learned from Atlas and from the users who helped us understand how agentic tools can make browser-based work more useful,” the company writes. “We’ll begin sunsetting the standalone Atlas browser, and will share information with users about how to transition to ChatGPT.”

The post OpenAI is folding Codex into the ChatGPT app — and taking aim at Claude Cowork appeared first on The New Stack.

Pure Virtual C++ 2026 is almost here: a free, one-day virtual conference for the whole C++ community, streaming Tuesday, July 21, 2026 at 9:00 AM PT on YouTube (Microsoft Reactor) and Twitch, with on-demand recordings on the Visual Studio YouTube channel afterward. Register now →

This is the first post in our three-part Meet the Speakers series. Over the next week we’ll introduce you to the people behind this year’s featured sessions and the problems they’re helping you solve. The theme of today’s post is one that every C++ developer feels in their bones: building faster, running faster.

Why this theme matters

Slow builds and heavyweight binaries are a tax every C++ team pays, every single day. The two sessions below address that tax from different angles: one by modernizing how your code is compiled with C++20 modules, the other by putting an AI agent to work finding and fixing the real bottlenecks in your build. If you’ve ever watched a progress bar instead of writing code, these talks are for you.

Ryan Shepherd: C++/WinRT: Build faster and smaller with C++20 modules

Ryan is a Senior Software Engineer on Windows, where he works on developer fundamentals: WinRT, C++/WinRT, the SDKs, and the CRT. Away from the keyboard he’s a freelance trombonist who also dabbles in composition, photography, baking, and camping with his wife and two dogs.Follow Ryan: GitHub @DefaultRyan

What the session is about. C++/WinRT recently gained support for C++20 modules, and the payoff is real: the Windows Terminal team adopted it and cut their build time by roughly 15% while shedding tens of gigabytes of build-time disk usage. Ryan walks through how that support works and what it takes to adopt modules in your own C++/WinRT code.

What you’ll learn

• How modules change the compilation model and why that translates into faster builds and smaller build footprints.
• The concrete before/after story from Windows Terminal’s adoption.
• What you need to get started: C++/WinRT 3.0 or later and MSVC Build Tools 14.50 or later.

Why C++ developers should attend. Modules are one of the highest-leverage modernization steps available today, but adoption still feels uncertain to many teams. Ryan turns it into a practical, evidence-backed decision with numbers you can take back to your own project.

Learn ahead

• Recommended starting point: Overview of modules in C++ : Microsoft Learn
• Also worth exploring:
  • Modules – cppreference
  • Compare header units, modules, and precompiled headers – Microsoft Learn
  • C++/WinRT documentation – Microsoft Learn
  • Windows Terminal on GitHub

David Li: Cut Your Build Times Without Becoming a Build Expert

David is the Game Developer Product Manager for Visual Studio, with 14 years in the software industry and a genuine passion for developer productivity. A gamer himself, he spends his off-hours with his baby and dog and conquering the world in Europa Universalis V.Follow David: X @thecpppm

What the session is about. This session shows how GitHub Copilot build performance for Windows tackles slow C++ builds while keeping you in the driver’s seat. You’ll see the full agentic loop: capture a build trace, surface the real hotspots (expensive headers, heavy template instantiations), apply targeted fixes, and verify each one with before-and-after numbers. For iterative cases, Copilot keeps the changes that help and rolls back anything that regresses, including honest tradeoffs like a slightly slower clean build in exchange for much faster incremental build. You end up with results you can trust and understand.

What you’ll learn

• How to find and fix real build bottlenecks in minutes instead of days.
• How every change is measured and kept.
• How you stay in control: Copilot does the heavy lifting, but you make the calls on what to keep.

Why C++ developers should attend. Build performance work has traditionally required dedicated build systems expertise and deep tooling knowledge. This session puts that expertise within reach: Copilot does the heavy analysis from a simple prompt while you stay in control of every change.

Learn ahead

• Recommended starting point: Now in Public Preview: GitHub Copilot build performance for Windows : C++ Team Blog
• Also worth exploring:
  • Project-Specific Build Optimizations with GitHub Copilot – C++ Team Blog
  • C++ Build Insights – Microsoft Learn
  • vcperf build-analysis tool on GitHub

Register today

Both talks are featured sessions at Pure Virtual C++ 2026. Register for free →

Next up in the series: The AI-Native C++ Developer Workflow, where we meet Sinem Akinci and Augustin Popa and dig into Copilot across the CLI and Visual Studio. Can’t make it live? Every session will be available on-demand on the Visual Studio YouTube channel after the event.

See you there!

The post Pure Virtual C++ 2026 [Meet the Speakers, Part 1]: Build Faster, Run Faster appeared first on C++ Team Blog.

Upgrading a .NET application isn’t a single prompt.

Every upgrade begins with understanding your application, evaluating dependencies, planning the work, applying code transformations, fixing build failures, and validating the results. Each phase uncovers new information that shapes the work that follows. A dependency update can uncover compatibility issues, a build failure can change the next task, and dependencies between projects can change the order of work.

GitHub Copilot upgrade carries out that workflow. The GitHub Copilot upgrade agent assesses your application, generates a structured upgrade plan, creates implementation tasks, and executes the work.

Now you can follow that workflow in the GitHub Copilot app through an interactive upgrade canvas. Instead of piecing together progress across chat, generated Markdown artifacts, and code changes, the upgrade canvas gives you a live view of the modernization workflow as it unfolds.

The result is a .NET modernization experience that’s easier to follow, easier to review, and easier to steer.

From assessment to execution

The GitHub Copilot upgrade agent starts by assessing your .NET application and identifying what needs to change:

• What version of .NET is this application targeting?
• Which NuGet packages need to be updated?
• Are there breaking API changes?
• Which projects can be upgraded independently?
• What should happen first?

From there, the agent generates a structured upgrade plan and breaks the work into actionable implementation tasks. As execution begins, the canvas reflects the latest state of the upgrade, including the assessment, upgrade plan, implementation tasks, execution progress, code changes, build failures, and final results.

Instead of asking the agent to summarize what happened or piecing together progress from generated artifacts, you can follow the modernization effort from assessment through execution in a single view.

Available wherever you work

While the GitHub Copilot app provides the interactive upgrade canvas, GitHub Copilot upgrade is also available across the developer tools you already use:

• Visual Studio – Built directly into Visual Studio. Right-click your solution or project in Solution Explorer and select Modernize to start a .NET upgrade.
• Visual Studio Code – Install the GitHub Copilot upgrade extension, select the Upgrade agent from the agent picker dropdown, and prompt it to modernize your .NET application.
• GitHub Copilot CLI – Install the GitHub Copilot upgrade plugin to assess, plan, and execute .NET upgrades directly from the terminal.

Whether you prefer working in an IDE, the terminal, or the GitHub Copilot app, you can use the same upgrade workflow across every surface.

Get started

Getting started takes just a few clicks.

1. Add the GitHub Copilot upgrade marketplace. If you don’t already have the GitHub Copilot app installed, you’ll be prompted to install it first.
2. In the Add plugin marketplace? dialog, select Allow.
3. In the Plugins window, select Add marketplace.
4. Select Install for the upgrade-agent plugin.
5. Open your repository, start a new agent session, and select the Upgrade agent from the agent picker dropdown.

To open the interactive upgrade canvas:

1. In the upper-right corner of the GitHub Copilot app, select the review panel icon (Toggle review panel).
2. In the review panel, select + (Open in panel).
3. Choose Upgrade Dashboard.

The Upgrade Dashboard opens an interactive upgrade canvas where you can assess your application, review the upgrade plan, track execution, and monitor your modernization effort from start to finish.

Try it on your next .NET upgrade, and share your feedback or ideas in the GitHub Copilot upgrade repository.

The post Modernize .NET applications in the GitHub Copilot app appeared first on .NET Blog.