Google has decided to retire Gemini CLI for most individual developers and push them towards Antigravity CLI, its new command-line tool integrated into the Antigravity 2.0 platform. The transition has a very specific date: on 18 June 2026, Gemini CLI and the Gemini Code Assist IDE extensions will stop serving requests for free users, Google AI Pro, Ultra and Gemini Code Assist for individuals.
The change may look like a simple product migration, but for the developer community it carries a more uncomfortable meaning. Gemini CLI was born as an open source AI agent for the terminal, with an Apache 2.0 licence, MCP integration, support for local tools, command execution, file editing and direct access to Gemini models. Google presented it as an open, extensible tool designed for people who live in the command line. Less than a year later, the practical future of that tool is being moved towards a proprietary alternative that, according to Google itself, will not have full feature parity from day one.
The problem is not just that Google is killing another product
Google has a long history of retired products, but Gemini CLI touches a different nerve. It was not just a closed application that users consumed. It was an open repository where the community could read the code, report bugs, propose improvements, submit contributions and build extensions. The project page itself encouraged contributions through bug reports, documentation, code improvements and MCP servers.
That is the social contract many developers feel has been broken. The licence is still there. The code does not disappear. Anyone can fork Gemini CLI and keep working on the interface. But the real value of the tool was not only in the harness, but in access to the engine: Gemini models, associated quotas, endpoints and the service controlled by Google.
In a traditional open source project, if a company changes course, the community can continue. In an AI tool connected to proprietary models, that escape route is much weaker. The shell can be preserved, but not necessarily the intelligence that made it useful. Gemini CLI leaves an important lesson for developers: in AI, opening the client is not the same as opening the platform.
Google argues that Antigravity CLI better matches current workflows, with faster execution, support for asynchronous tasks, a unified architecture with Antigravity 2.0 and the ability to coordinate multiple agents in the background. It also says it preserves critical functions such as Agent Skills, Hooks, Subagents and Extensions, now converted into Antigravity plugins. But the migration is not neutral: it changes the control model.
From open terminal to closed platform
For many technical teams, Gemini CLI was attractive because it fitted well into existing workflows. It could be run from the terminal, integrated into scripts, used for non-interactive tasks, connected to MCP servers and adapted through files such as GEMINI.md. That combination made it useful for code review, feature creation, debugging, documentation generation, large repository analysis and internal automation.
Antigravity CLI appears to point to a more ambitious model: an integrated agentic platform, with a shared backend, desktop app, CLI and SDK for custom workflows. The issue for the community is not that Google wants to evolve its product. It is that the evolution moves towards a less open environment, with less ability to inspect it and with a very short transition window for those who had adopted Gemini CLI as a daily tool.
The unequal treatment does not help calm the debate either. Gemini Code Assist Standard or Enterprise users keep access unchanged. It will also remain possible to access the service through paid Gemini API keys and Gemini Enterprise Agent Platform. The cut mainly affects individual users, free users or personal plan users. In other words, the profile that often contributes the most, tests the most, reports bugs and helps popularise tools in developer communities.
| Aspect | Gemini CLI | Antigravity CLI |
|---|---|---|
| Openness model | Open source, Apache 2.0 | Not published as an equivalent open source project at the time of transition |
| Main use | AI agent in the terminal | CLI inside the Antigravity 2.0 platform |
| Integrations | Local tools, MCP, extensions, scripts | Antigravity plugins, subagents and asynchronous workflows |
| Community | Issues, contributions and forks on GitHub | More controlled by Google |
| Critical date | Stops serving requests for many users on 18/06/2026 | Available as replacement from the announcement |
| Enterprise users | Keep access to Gemini CLI | Can also test Antigravity CLI |
The lesson for developers is clear: looking at the licence is not enough. You also need to look at who controls the runtime, the model, authentication, quotas, APIs and roadmap. Open source protects the code, but it does not necessarily protect the service.
The lock-in is not in the repository, but in the dependency
The Gemini CLI case is useful because it shows a modern form of vendor lock-in. It does not look like the classic lock-in of a proprietary database or an enterprise API that is hard to migrate from. Here, the lock-in comes from something more subtle: an open tool that depends on a closed model.
A team may have integrated Gemini CLI into review scripts, internal pipelines, documentation generation, pull request analysis or support tasks. If the service stops responding for its type of account, the client code does not solve the problem. Workflows need to be adapted, credentials migrated, behaviours revalidated, limits tested, costs reviewed and the new tool checked to see whether it produces equivalent results.
For personal projects, this may be an annoyance. For teams that have automated tasks, it can become unexpected technical debt. Migrating an AI agent is not just a matter of replacing a binary. Prompts, permissions, expected outputs, shell integration, file access, MCP behaviour, logs, security and auditing all need to be reviewed.
The practical lesson for developers is not to abandon every tool from large vendors. That would be unrealistic. The lesson is to design abstraction layers. If a team uses AI agents in important processes, it should avoid making the whole workflow depend on a single CLI, a single provider and a single model.
Reasonable measures include keeping prompts and workflows in owned repositories, separating the client from the provider through adapters, documenting dependencies, testing MCP-compatible alternatives, preserving non-AI execution paths for critical tasks and measuring what happens if an API becomes unavailable.
Governance matters as much as the licence
Open source is not just publishing code. It also creates expectations of continuity, governance, participation and reciprocity. When a company benefits from external contributions to improve a tool and then moves the real future of the product towards a closed alternative, the community perceives an asymmetry: collective value flows in, but strategic decisions remain out of reach for those who contributed.
This does not mean Google has violated the Gemini CLI licence. That is not the point. The issue is trust. Developers do not only invest lines of code; they invest time, reputation, extensions, documentation, internal processes and learning. When a tool changes direction with 30 days’ notice, that capital is exposed.
For a developer-focused publication, the case also serves as a warning about how to evaluate AI tools. Before adopting a programming agent, it is worth asking questions that sounded exaggerated two years ago. Can the provider withdraw access? Is there a stable API? Can the tool switch models? Do data leave the local environment? Does the licence cover only the client or also the components needed to operate it? Is there a community with real decision-making power?
AI-assisted development will increasingly depend on agents, CLIs, IDEs, MCP servers, workflows and models connected to private code. That layer will become as important as CI/CD, package managers or repository platforms are today. That is why governance decisions are no longer an ideological detail: they are an operational risk.
A warning for the new generation of AI tools
Gemini CLI does not disappear completely. The code remains available, enterprise customers keep access and Google offers a path towards Antigravity CLI. But trust is not migrated with a command. For many developers, the issue will not be learning another CLI, but accepting that a tool presented as open can leave them out when the provider reorganises its strategy.
Antigravity CLI may end up being technically better. It may run agents in parallel, work in the background, integrate better with Google’s ecosystem and solve cases Gemini CLI did not handle well. But the move leaves a question that goes beyond Google: how much control is a developer willing to hand over to tools that depend on closed models?
Open source has always given developers an exit: copy, adapt, continue. Generative AI weakens that exit when the essential component sits on someone else’s server. Gemini CLI has shown that limit clearly. Open code still matters, but in the age of agents it is also necessary to demand openness in protocols, model portability, governance and service continuity.
For technical teams, the conclusion should not be emotional, but practical: treat AI tools as critical dependencies. Review their architecture, measure shutdown risk, prepare migration plans and avoid allowing a unilateral decision by a provider to break complete workflows.
Frequently asked questions
What changes with Gemini CLI on 18 June 2026?
Gemini CLI and the Gemini Code Assist IDE extensions will stop serving requests for free users, Google AI Pro, Ultra and Gemini Code Assist for individuals. Standard and Enterprise customers keep access.
Does Gemini CLI stop being open source?
No. The repository remains published under the Apache 2.0 licence. What changes is practical access to the service for many users, because the tool depended on Google’s models and infrastructure.
What is Antigravity CLI?
It is Google’s new CLI integrated into Antigravity 2.0, designed for agentic workflows, asynchronous tasks, subagents and a unified architecture with Google’s new development platform.
What should developers learn from this case?
That an open AI tool can still depend on a closed provider. It is sensible to design portable workflows, separate prompts and business logic, test alternatives and avoid basing critical processes on a single CLI controlled by one company.