# The big players in AI coding: models, tools, and who to follow
> A guide to OpenAI, Anthropic, Cursor and SpaceX, Google, Meta, GitHub, and OpenCode: their coding models, tools, influence, and people to follow.
Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-10-28 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/ai-coding-landscape/
OpenAI makes Codex. Anthropic makes Claude Code. Cursor lets you use models from several competing labs, while also developing its own. OpenCode lets you choose a provider and change it later.
Then there are Google, Meta, Microsoft, and a growing number of model companies whose names you might only encounter in a model picker.
Following AI coding gets confusing because these companies compete at different levels. A company can supply the model inside a rival's product. An editor can become a model maker. A model that leads a benchmark can be unavailable in the tool you use.
I want to explain who does what, where their influence comes from, and who I would follow to keep up. Product names, model families, and availability below were checked on **October 28, 2026**. This is a map of the industry, with my assessment of its influence, rather than a market-share ranking or a new hands-on model test.
## First, separate the model from the coding agent
The **model** reads its input and generates a response. It can also request a tool call, such as reading a file or running a test.
The **agent software** carries out those requests, sends back the results, and keeps the work going. It decides what files and commands are available, how to ask for permission, and how to show you the changes. People often call this surrounding software the *harness*.
The **interface** is where you work with it. That could be a terminal, an editor, a desktop app, or a browser.
For example, Claude Opus is a model. Claude Code is an agent product. You can also use an Opus model inside Cursor, where different software manages the conversation and tools.
```mermaid
flowchart TD
accTitle: A model can power several competing coding tools
accDescr: Anthropic supplies a Claude model. Claude Code, Cursor and OpenCode can each use that model through their own agent software to read files, edit code and run checks.
A[Anthropic Claude model] --> B[Claude Code]
A --> C[Cursor]
A --> D[OpenCode]
B --> E[Project files and commands]
C --> E
D --> E
```
This explains why two people can use the same model and have different experiences. The instructions, available tools, context, and permission settings all affect the result.
If these terms are new, my free [AI Fundamentals Course](https://flaviocopes.com/courses/ai-fundamentals/) walks through models and agents with small exercises.
## The map at a glance
These are the main groups I would keep track of:
| Company or project | Models to recognize | Coding tools to recognize | Where its influence comes from |
| --- | --- | --- | --- |
| OpenAI | GPT-6 Astra, GPT-6.1 Sol and Terra, GPT-6 Luna | Codex | Models combined with a complete agent product and the ChatGPT ecosystem |
| Anthropic | Claude Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1 | Claude Code | Its own agent and Claude models inside other coding tools |
| Cursor / SpaceX | Composer 2.5, Grok 4.7 | Cursor, Grok Build, Grok Bot | Developer workflow, model training, and compute under the same parent |
| Google | Gemini 4 Carbon (limited access), Gemini 4 Argon, Gemini 3.8 Flash | Antigravity, Antigravity CLI, Jules | Models, developer products, and cloud infrastructure |
| Meta | Muse Wonder, Muse Spark, Muse Glimmer | Muse Code; Wonder also in Cursor | Model research, its own agent, and downloadable models |
| Microsoft / GitHub | MAI-Code, plus models from other labs | GitHub Copilot, Agent HQ | Editors, repositories, pull requests, and company purchasing decisions |
| Anomaly / OpenCode | Connects models from other providers | OpenCode | Open source agent software and provider choice |
The sections below link to the current documentation behind those names. The influence column is my interpretation of what each group controls.
## OpenAI: Codex and the GPT models
[Codex](https://learn.chatgpt.com/docs) is OpenAI's coding agent. It can work with a repository, edit files, run commands, and help review changes. You can use it through desktop, terminal, IDE, and web workflows.
The model names are a separate choice. OpenAI's current [model catalog](https://developers.openai.com/api/docs/models) puts **GPT-6 Astra** at the top for demanding work, **GPT-6.1 Sol** at a lower cost for complex tasks, and **GPT-6 Luna** on the efficient end. **GPT-6.1 Terra** emphasizes visual reasoning and computer use, among other tasks.
A higher version number alone doesn't tell you which one to pick. Astra and Sol occupy different places in the range. Availability also differs between the API and the product you sign into.
OpenAI's advantage is that it develops both the models and the software around them. It can improve how a model uses tools while also changing the application that gives it those tools.
That gives it considerable influence over how people expect a coding agent to behave. A new capability can arrive as a model improvement, an app feature, or both.
I use the Codex desktop app, and my [Codex guide](https://flaviocopes.com/codex/) explains that workflow. There's also a separate [Codex CLI tutorial](https://flaviocopes.com/codex-cli/) if you prefer the terminal.
For a quick visual introduction, this is OpenAI's **February 2026 Codex app demo**. It shows the agent workspace idea; some interface details have changed since then.
[Watch the Codex demo on YouTube](https://www.youtube.com/watch?v=HFM3se4lNiw).
**Who to follow:** [Alexander Embiricos (@embirico)](https://x.com/embirico) and [Tibo Sottiaux (@thsottiaux)](https://x.com/thsottiaux) for Codex product updates. I would also keep the [official changelog](https://learn.chatgpt.com/docs/changelog) bookmarked, because a social announcement doesn't always explain rollout and account availability.
## Anthropic: Claude Code and models used across the industry
The name is **Claude Code**. Claude is Anthropic's model family; Claude Code is its coding agent.
The [Claude Code overview](https://code.claude.com/docs/en/overview) describes a tool that reads code, edits files, and runs commands. It now spans terminal, IDE, desktop, and browser workflows, so describing it as only a terminal tool misses much of the product.
Anthropic's current range includes **Opus 5.5**, **Sonnet 5.5**, **Haiku 5.5**, and **Fable 5.1**. The [model documentation](https://platform.claude.com/docs/en/models/opus-5-5/overview) places them at different points for capability, speed, and cost. Fable is the expensive tier for demanding work; Haiku is the efficient tier. Opus and Sonnet cover much of the work between those ends.
Anthropic has influence through both its own tool and other companies' tools. If you select Claude inside Cursor or Copilot, Anthropic supplies the model even though another company provides the interface.
That relationship creates an interesting tension. Anthropic benefits when a rival editor sells access to Claude. It also wants developers to choose Claude Code directly.
For developers, this means a decision about the model can be separate from a decision about the application. You might like Claude's results and prefer another tool's review interface.
Anthropic's **original February 2025 launch demo** shows Claude Code exploring a project and making changes. Treat it as a demonstration of the workflow, rather than current installation or pricing guidance.
[Watch the Claude Code demo on YouTube](https://www.youtube.com/watch?v=AJpK3YTTKZ4).
**Who to follow:** [Boris Cherny (@bcherny)](https://x.com/bcherny), who [created Claude Code](https://borischerny.com/about/). For changes you depend on, follow the [Claude Code changelog](https://code.claude.com/docs/en/changelog) too.
## Cursor and SpaceX: the editor, Grok, and the company behind them
Cursor is now part of SpaceX. The acquisition [closed on August 14, 2026](https://cursor.com/blog/joining-spacex/), so the old description of an independent Cursor partnering with xAI is out of date.
You'll see xAI, SpaceXAI, and **SpaceX Super Intelligence**, or **SpaceXSI**, in discussions of this group. The current [x.ai website uses SpaceXSI](https://x.ai/company), and its [official social account is @SpaceXSI](https://x.ai/contact).
The products still have their own names:
- **Cursor** is the coding environment, including editor and agent workflows.
- **Composer 2.5** is Cursor's own coding model.
- **Grok 4.7** is the group's broader coding and knowledge-work model.
- **Grok Build** is a coding agent you run on your computer. The same name also covers a web and mobile builder that turns a description into an app.
- **Grok Bot** gives an AI teammate a persistent cloud computer.
[Composer 2.5](https://cursor.com/composer) is especially interesting because Cursor moved from building around other labs' models to training models itself. Cursor says it builds on Moonshot's Kimi K2.5 checkpoint. Open model releases can therefore influence products that don't look like open model projects at all.
[Grok 4.7](https://docs.x.ai/developers/grok-4-7) is available through the API and inside Cursor and Grok Build. Cursor also continues to offer competing labs' models. Its [current model and pricing documentation](https://cursor.com/docs/models-and-pricing) explains how the group's models and third-party models are billed under the newer subscription structure.
That billing distinction matters. Access to a model in a picker doesn't mean your plan includes its usage.
My assessment is that this group has unusual control over the whole process: training infrastructure, models, and the application developers use every day. Cursor also knows how to package agent work into an interface people can use.
The question I would watch is how much room it keeps giving competing models. A tool that offers several providers is useful precisely because developers can compare them.
If the product names still sound similar, my [Grok Bot guide](https://flaviocopes.com/grok-bot/) and [Grok Bot versus Cursor Projects comparison](https://flaviocopes.com/grok-bot-vs-cursor-projects/) explain the different workflows.
**Who to follow:** [Michael Truell (@mntruell)](https://x.com/mntruell) and [Aman Sanger (@amanrsanger)](https://x.com/amanrsanger) for Cursor's direction and model work, and [Lauren Tan (@poteto)](https://x.com/poteto) for Grok Bot updates. Use [@SpaceXSI](https://x.com/SpaceXSI) for the wider Grok product announcements.
## Google: Gemini and Antigravity
Google builds the **Gemini** models. On October 28 it announced [Gemini 4 Carbon](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/), with reported improvements in coding, long-running agent work, and cybersecurity. Access starts with selected cyber defenders through its Fairwind Program; wider access is still to come. [Gemini 4 Argon](https://ai.google.dev/gemini-api/docs/models/gemini-4-argon/) remains the generally available model for complex software engineering and multi-step agent work.
Its coding tools need a little more explanation. [Antigravity 2.0](https://antigravity.google/blog/introducing-google-antigravity-2) is a standalone agent desktop app, alongside the Antigravity IDE. [Antigravity CLI](https://antigravity.google/blog/introducing-google-antigravity-cli) brings the agent workflow to the terminal.
Google also offers [Jules](https://jules.google/), an asynchronous coding agent. It works on a repository in a cloud environment and prepares changes for review. That is useful when you want to hand off a defined repository task and return to the result later.
Be careful with older Gemini CLI tutorials. Google [ended the consumer Gemini CLI and Gemini Code Assist path on June 18, 2026](https://developers.google.com/gemini-code-assist/docs/deprecations/code-assist-individuals), directing those users toward Antigravity. Gemini CLI's API-key and enterprise paths have different rules; the project itself hasn't disappeared.
Google's influence comes from building the models and owning places developers already work. It can put an agent into a dedicated app, an existing development environment, or a cloud workflow.
Antigravity also [supports models from other companies](https://antigravity.google/docs/models/). Once again, choosing the tool and choosing the model are separate decisions.
**Who to follow:** [Logan Kilpatrick](https://blog.google/authors/logan-kilpatrick/) for Google AI Studio and the Gemini API. For the research direction, read [Koray Kavukcuoglu's Gemini 4 Carbon announcement](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/). The [Antigravity blog](https://antigravity.google/blog/) is the more focused source for coding product changes.
## Meta: look beyond Llama
A description of Meta that stops at Llama misses its current coding products.
Meta [introduced Muse Wonder and Muse Wonder Full on October 12](https://about.fb.com/news/2026/10/introducing-muse-wonder-models/). These models target agent work, including complex software engineering.
[Meta's developer platform](https://dev.meta.ai/docs/overview) now includes **Muse Wonder**, **Muse Spark**, and **Muse Code**, its terminal and CI coding agent. Wonder is also [available through Cursor](https://cursor.com/docs/models/muse-wonder). Wonder Full is only on the [Power Usage and Maximum Usage](https://dev.meta.ai/docs/muse-code/subscriptions) Muse Code plans, so don't assume every Muse model is available through the same API or plan.
Meta has downloadable models too. Its documentation lists **Muse Spark Open** and **Muse Glimmer**, with Glimmer aimed at local and edge use under Apache 2.0. That doesn't make the entire Muse family downloadable. Check the license and access conditions for the particular model.
I would watch Meta for both its coding models and what other developers build on its released weights. A model can influence the industry through products built around it, even if you never use the original maker's app.
I haven't run my own Muse Wonder comparison yet. My [Muse Wonder in Cursor post](https://flaviocopes.com/muse-wonder-cursor/) explains how I would evaluate it against the model I already use.
**Who to follow:** [Alexandr Wang (@alexandr_wang)](https://x.com/alexandr_wang) for Meta's AI direction, and [AI at Meta](https://ai.meta.com/) for releases. For actual access, I would check the developer documentation before relying on a launch post.
## Microsoft and GitHub: influence through the development workflow
Microsoft and GitHub belong in this conversation even when the selected model comes from another company.
**GitHub Copilot** spans editor, terminal, desktop, and repository workflows. The [Copilot app](https://github.blog/news-insights/product-news/github-copilot-app-the-agent-native-desktop-experience/) brings agent work into a desktop interface, while GitHub remains where many teams review and merge changes.
GitHub's [supported-model list](https://docs.github.com/en/copilot/reference/ai-models/supported-models) includes models from several competing labs. Microsoft also develops its own coding models, including [MAI-Code-1.1-Flash](https://microsoft.ai/models/mai-code-1-flash/).
There is another distinction here. [Agent HQ can bring Claude and Codex into GitHub as agents](https://github.blog/news-insights/company-news/pick-your-agent-use-claude-and-codex-on-agent-hq/). Picking a Claude model inside Copilot and assigning a task to Anthropic's Claude agent are different workflows, even if both involve Anthropic technology.
My assessment is that GitHub has some of the strongest structural influence in this market. A team may try several models while keeping its repositories, issues, review process, and organization policies in GitHub.
A new agent has to fit that workflow. GitHub can make agents available inside it.
**Who to follow:** [Mario Rodriguez](https://github.blog/author/mariorod/), GitHub's Chief Product Officer, for product direction. The [GitHub changelog](https://github.blog/changelog/) is useful for availability and organization controls.
## OpenCode: influence through an open agent
[OpenCode](https://opencode.ai/) is an open source coding agent from Anomaly. Its [source is available under the MIT license](https://github.com/anomalyco/opencode).
It connects to hosted providers and local models. You can change the model while keeping OpenCode as your interface. It also offers Zen, its hosted route to a curated set of models.
That makes it a different kind of competitor. Its appeal is the ability to inspect and extend the agent software, and to choose who supplies the model.
OpenCode's success doesn't require one particular model company to win. A stronger model from any supported provider can become useful to its users.
There are limits to that independence. You still need access to the model, the provider's terms still apply, and running an open source agent doesn't make hosted inference free or local. The code and context sent to a remote model still leave your machine.
My [OpenCode tutorial](https://flaviocopes.com/opencode/) walks through the tool. If you want to connect an existing subscription, read [the provider-specific options](https://flaviocopes.com/opencode-claude-codex/) rather than assuming every chat subscription works with every agent.
**Who to follow:** [Dax (@thdxr)](https://x.com/thdxr), whose [GitHub profile](https://github.com/thdxr) identifies his OpenCode work, and [@opencode](https://x.com/opencode). The [release history](https://github.com/anomalyco/opencode/releases) is useful when configuration or plugin behavior changes.
## The other model makers deserve attention too
DeepSeek, Alibaba's Qwen team, Moonshot, Z.ai, and Mistral all belong on a developer's radar. You can encounter their models through an API, a local runtime, or a tool made by somebody else.
Moonshot is a concrete example of influence reaching beyond its own brand. Cursor's Composer uses a Kimi checkpoint as its foundation.
Mistral also builds both models and tools. Its [Vibe agent](https://mistral.ai/news/vibe-agent/) covers coding and broader work, while [Mistral Large 4](https://mistral.ai/news/mistral-large-4/) launched in public API preview in October. The announcement promised weights later in the month; an API release and a downloadable release are separate events.
For open models, check the exact model's license and hardware requirements. A downloadable model can still be much too large for your laptop. Smaller models can be useful for focused tasks without matching the largest hosted model on difficult repository work.
Here are useful starting points for following those teams:
| Team | Models or tools to recognize | Where to follow releases |
| --- | --- | --- |
| DeepSeek | DeepSeek-V4-Pro and DeepSeek Flash | [Official API documentation](https://api-docs.deepseek.com/) and [repositories](https://github.com/deepseek-ai) |
| Alibaba / Qwen | [Qwen3.8-Max](https://qwen.ai/blog?id=qwen3.8) and Qwen Code | [Qwen's blog](https://qwen.ai/blog) and [Qwen Code updates](https://qwenlm.github.io/qwen-code-docs/en/blog/) |
| Moonshot | Kimi models | [Official repositories](https://github.com/MoonshotAI) |
| Z.ai | GLM models | [Official documentation](https://docs.z.ai/) |
| Mistral | Large 4 and Vibe | [Mistral news](https://mistral.ai/news) |
Release notes and model cards are often more useful than another account repeating a benchmark screenshot.
## The companies building a complete development environment
There is another group worth following if you want to go from an idea to a running application.
Amazon's **Kiro** spans IDE, CLI, and web workflows. If you know Amazon Q Developer, start with the [current migration guide](https://kiro.dev/docs/upgrade-guides/migrating-from-q-developer/) to understand the product transition. I would follow the [Kiro blog](https://kiro.dev/blog/) for its coding tools.
Cognition makes **Devin**. It acquired Windsurf, and the editor became [Devin Desktop in June 2026](https://cognition.com/blog/introducing-devin-desktop). Follow Scott Wu and Jeff Wang through Cognition's announcements for the direction of that combined product.
Replit combines an agent with the environment where the application runs. Its [Agent 4 announcement](https://replit.com/blog/introducing-agent-4-built-for-creativity) shows how it approaches building and iterating inside that environment. Follow [Amjad Masad](https://replit.com/blog/author/amjad-masad) for Replit's direction.
Lovable focuses on building full-stack applications through conversation, with hosting and integrations around that workflow. Follow cofounder [Anton Osika](https://lovable.dev/video/building-lovable-10m-arr-in-60-days-with-15-people-anton-osika-ceo-and-co-founder) and the [product's updates](https://lovable.dev/).
These companies influence who can build software and how quickly they can get a first version online. When evaluating them, I would check how easily I can inspect the source, export it, and continue development elsewhere. That matters once the application grows beyond the first working demo.
## So who has the most influence?
My answer depends on which decision we're talking about.
| Decision | Players I would watch most closely | Why |
| --- | --- | --- |
| What a strong coding model can do | OpenAI and Anthropic, alongside Google and the other model labs | Their model releases change which tasks agents can attempt |
| How developers work with an agent | Cursor, Codex, Claude Code, Antigravity | Their interfaces decide how you give instructions, supervise work, and review results |
| Which tools a company adopts | Microsoft / GitHub, plus the major enterprise providers | Existing repositories, policies, and purchasing relationships affect adoption |
| Whether you can change providers | OpenCode and other open agent projects | They let developers keep an interface while switching the underlying model |
| What can run outside a hosted API | Open-weight model makers, including Meta and Qwen | Released weights let others host, adapt, and build on a model |
For everyday AI coding, **OpenAI and Anthropic are central companies to follow** because they combine widely available model families with their own coding agents. Cursor has substantial influence over the experience of using models, and its place inside SpaceX adds infrastructure and model development to that position.
GitHub can remain influential even when the preferred model changes. OpenCode gives developers another way to respond to those changes without replacing their entire workflow.
Those are judgments about the products and relationships above. Revenue, user counts, benchmark scores, and GitHub stars measure different things. I wouldn't combine them into a precise-looking league table.
## What I use at the moment
At the moment, I mainly use [Grok Bot](https://flaviocopes.com/grok-bot/) and [Codex](https://flaviocopes.com/codex/). GPT-6.1 Sol is the model I use most.
I like keeping a task under control and reviewing it before moving on.
## How I would keep up without trying everything
I would follow the people building the tools I use, keep their changelogs bookmarked, and run occasional comparisons on my own code.
For a comparison, I would start with a reproducible bug and give both agents the same starting files and instructions. Then I would check whether the fix works, how much unrelated code changed, and how long review takes. Cost matters too, especially when an agent makes many model calls to finish one task.
If I wanted to compare models, I would keep the surrounding agent and settings as similar as possible. If I wanted to compare complete products, I would let each use its own tools and record that difference. Those experiments answer different questions.
My advice is to pick a tool that makes the changes easy to inspect. Learn it well enough to recognize when the model has misunderstood the task. Then try another model or agent when you have a specific problem with your current setup, and compare the finished work.