OpenAI says the new model comes close to GPT-6 Astra on agentic coding, computer use and professional work, at a fifth of Astra's standard token prices. It is available in the API and on the paid ChatGPT plans.

A dot is an agent that keeps working on a person's goals, connects to other apps through plugins, and can be reached in ChatGPT, Slack or Teams. OpenAI describes access and permission settings, and a review and approval step for actions.

Developers can run Codex on a computer, from a phone or in the cloud. A team can share one development setup with approved settings and permissions, so tasks start quickly from any device.

Engineers can read summaries, explore changes and ask Codex about possible issues before commenting on a GitHub pull request or GitLab merge request. With automatic reviews, Codex takes a first pass in the cloud.

A team can have an AI agent scan its repositories, keep checking new commits for security problems and prepare fixes for engineers to review.

Engineering teams can build AI agents through the OpenAI API that operate other software on screen and coordinate with other agents.

A team can keep its documents, shared pages and AI agents in one ChatGPT workspace instead of separate personal chats.

Anthropic says the new model runs more than 30 percent faster than Sonnet 5 and costs up to 30 percent less for most work. It is strongest at well-scoped everyday tasks, such as fixing bugs and making documents, slides and spreadsheets.

A team gives one Grok Bot, SpaceXAI's AI agent, the files, apps and skills it needs, and everyone works from that shared context. Each person's conversations with the Bot stay private. Team Bots are in public beta on the Teams and Enterprise plans.

An AI agent can deploy code, set security policies and manage domains on Cloudflare through one command-line tool with JSON output and built-in command search.

A developer on a paid plan can package connectors and skills as a Claude plugin and submit it to a public directory. Submissions pass automated validation and safety scanning, and the developer sees installations by product and version. A skill written inside one team can become a plugin that others install.

An issue can be raised from a chat thread, with the thread linked back and duplicates checked, so a discussion in chat becomes tracked work without anyone retyping it.

Security fixes applied by an agent become stored patterns that the organisation's other Copilot features reuse, so remediation conventions accumulate per repository rather than per person. The feature is opt-in and in public preview.

Home puts chat and tasks handed to Copilot on one start page, and Code lets people who are not developers build apps by describing them. Autopilot, an agent that runs recurring work without being prompted, enters a private preview at the end of September. Home and Code reach Microsoft's early-access programme first.

An app built by someone outside engineering can run under the company's own sign-in and data policies, and IT sees every such app in one list. A developer can take the app's code from Git and keep building on it, with no separate hosting project.

A team can ask Claude Code to review its instruction files (CLAUDE.md, skills, agents and commands) for phrasing written for older AI models. The report opens with out-of-date file paths and commands, and with instruction files that contradict each other.

When a task goes from an issue to Linear's coding agent, simple work goes to a cheaper AI model and harder work to a reasoning model. The person assigning the task no longer picks the model, and administrators decide which models the workspace allows.

From 22 October, Copilot features that an enterprise has not configured follow one enterprise-wide default. This covers code review policies and MCP servers, the connections that give agents access to other tools. The options are to enable everything, to require approval, or to let each organisation choose. An administrator decides once whether teams get new agent features on arrival or after a review.

Before a change is merged, the agent writes a monitoring plan for a person to edit. After release, it compares live signals with a baseline and prepares a rollback for a person to approve. People edit the plan and approve the rollback instead of watching dashboards.

Each person, or a whole company, now sets once when the AI code review runs and how thoroughly it checks. Review depth becomes a company setting with someone responsible for it, instead of a choice made in each repository.

A team can set, per project, which files, network access and credentials a local coding agent may use before it runs. The limits live in a configuration file instead of depending on a person watching the terminal. The setting is off by default.

New projects in a group now start on that group's design system instead of the workspace default. A product team can keep its own design system without a central team approving each project.

A team can choose connectors, plugins and agents from one catalogue built on the open MCP and Agent Skills standards. It can also spend its existing Anthropic commitment on partner products instead of buying each integration separately.

At its Connect conference, Meta gave its personal agent Muse a pocket device and a place on its AI glasses. Muse can now work in Notion, GitHub and Mac apps, with permission.

An agent's workspace, dependencies and stored memory persist between runs, so a long-running agent task no longer starts from a clean checkout each time.

A team's design and copy conventions become a reusable file that the site agent follows across tasks. The file is captured from a conversation after a page is refined and travels with the project when it is remixed.

Anthropic says the new model does frontier-level work, including agentic coding, with far fewer tokens. It costs 40 percent less to run than Opus 5 and is more than 30 percent faster.

Sol is for demanding work and Luna for high-volume work. Both run in ChatGPT Work, Codex and the API, at lower prices and with higher usage limits.

Xiaomi released two models that read text, images, audio and video, under an open licence. A team can host them itself and give an agent a long codebase to work through.

The model works longer on hard tasks and checks its own work more carefully, at the same price and speed as Grok 4.6. It is available in the xAI API and in Cursor.

A repository can keep one agent instructions file that several coding agents read, so the team maintains one set of rules rather than a copy per tool.

On a re-review the reviewer sees only the agent findings still open, so the human check of agent-written code is shorter and the commit history records what was accepted.

A prototype built in v0 can now use the team's own published component library instead of a generic one. The prototype and the production design system then draw on the same package.

A skill enabled in the chat application is the same skill the engineer's terminal agent runs, so one list of skills serves the whole team without a separate installation step. An opt-out setting is available.

The team writes a scoring rubric as a prompt, covering task compliance, efficiency, verbosity, code quality and custom checks. A scoring agent grades each run, and people read the failures to adjust skills rather than reading every pull request.

The model reads text, images, audio and video and can call tools. An agent built on it can plan and carry out tasks such as editing, translating or summarising video.

A goal stated once becomes several agent threads across repositories with one shared memory, so the person steers and checks the work rather than briefing each session again.

A team can keep its agent skills, the written instructions agents follow, in a Notion database that people outside engineering can edit. One command installs them into any agent, so the skills no longer have to live in a code repository.

One conversation now produces documents, slides and designs, and the team decides per task whether Claude confirms before acting or runs unattended and reports back.

When a member uses up an AI credit allowance, they can ask for more inside the product. An organisation owner approves the request in settings, so running out of credit no longer stops the work outright.

A team writes instructions for AI agents once, as a skill file (SKILL.md), and keeps them in one library. The same file can be exported to the coding tools Claude Code, Codex and Cursor, so every tool follows one definition.

Linear's recurring agent workflows, called Loops, now react when an initiative, project or cycle changes. They can update Linear documents and post to Slack, so nobody has to rewrite the status by hand when scope moves.

Each engineer selects efficiency, balance or intelligence per tool, so model cost per task becomes an individual setting rather than a team default.