Seven Official Coding-Agent CLIs, One Command Center

Open Free Max 3.0 now drives seven official coding-agent command-line tools from a single native desktop application. Claude Code from Anthropic, Codex from OpenAI, the open-source OpenCode agent, Gemini from Google, Vibe from Mistral, Kimi Code from Moonshot, and Cursor Agent all run inside the same window. Each one keeps its own interactive terminal, its own login, and its own subscription. You choose which agent handles which task, and you can run several of them in parallel without leaving the app.

This is the headline change in the current public release. Before, the app supported a smaller set of agents and the wiring differed from one to the next. As of 3.0, all seven are available now, they share one consistent shell, and switching between them is a matter of picking a provider rather than opening a different tool. There is no lock-in to a single vendor and no hidden preference for one model family over another. The point of Open Free Max is to sit above the agents, not to replace them.

What changed, and when

The seven-CLI lineup did not land in one commit. It came together over several weeks of incremental work, and the dates matter because they show how each provider was added and tested rather than announced all at once.

Kimi Code support arrived on 2026-06-15. That change added Moonshot's agent to the roster of officially wired command-line tools, giving it the same terminal handling the other agents already used.

On 2026-06-29, the multi-CLI wiring was generalized across the whole application. Rather than treating each agent as a special case, Open Free Max moved to a shared model that covered Claude Code, Codex, OpenCode, Gemini, Vibe, and Kimi Code through one path. This is the change that turned a handful of separate integrations into a single command center, and it is what made adding another agent a smaller, more predictable job.

On 2026-07-28, Cursor Agent joined as the seventh CLI. Because the shared wiring was already in place, adding it followed the same pattern as the others: its own interactive terminal, its own provider settings, and a place in the resume picker. The same day brought the multi-CLI resume picker itself, which lets you reopen prior sessions across agents, including Codex rollouts.

Here is the full lineup as it stands in the current public release.

CLI	Provider	Status in 3.0
Claude Code	Anthropic	Available now
Codex	OpenAI	Available now
OpenCode	Open-source agent CLI	Available now
Gemini	Google	Available now
Vibe	Mistral	Available now
Kimi Code	Moonshot	Available now
Cursor Agent	Cursor	Available now

Every row in that table is available today, on the same release, on both supported desktop platforms. There is no waitlist, no separate beta channel for any single agent, and no feature flag you have to enable to reach one of them. That is the distinction the release is built around: these are shipped integrations, not previews.

One window, seven agents

The reason all seven can coexist is that each session runs in its own PTY, a pseudo-terminal that behaves exactly like the interactive shell you would get if you launched the agent by hand. Open Free Max does not screen-scrape output or wrap the agent in a custom protocol. It gives the official CLI a real terminal, forwards your keystrokes to it, and renders what the agent prints back. The agent runs the way its makers intended.

That design has a direct, practical payoff. You can run several sessions at once.

Imagine a Codex session refactoring a module while a Claude Code session drafts tests for a different part of the same repository, and a Gemini session answers a research question about an unfamiliar dependency, all in parallel, each in its own terminal pane, each holding its own history and its own working context without stepping on the others or sharing a single blocking prompt. Because every session owns a separate PTY, none of them waits on another, and closing or restarting one leaves the rest untouched. This is the difference between a true multi-agent workspace and a single chat box that can only talk to one model at a time.

The sessions are independent in the ways that count. Each has its own scrollback. Each has its own agent process. Each can be pointed at a different folder or a different task. When one agent finishes, you read its output and move on; you do not lose the others while you do.

Per-provider settings, driven by a schema

Seven agents do not share one set of options. Claude Code exposes different flags and behaviors than Gemini; Vibe is configured differently from Cursor Agent. Open Free Max handles this with per-provider settings that are schema-driven, which means the options shown for each agent come from a description of what that agent actually supports rather than from a hand-maintained form that drifts out of date.

The benefit for you is that the settings you see for a given CLI reflect that CLI. You are not offered a lowest-common-denominator panel that hides the controls one agent needs and invents controls another agent ignores. Each provider gets the surface it deserves, and the app keeps those surfaces consistent in look and feel even though the underlying options differ.

This approach also keeps the door open. Because the wiring is generalized and the settings are schema-driven, the internal cost of supporting another official CLI is lower than it would be with seven bespoke integrations. That is a statement about how the current code is structured, not a promise about any specific future agent. What ships today is seven; what the architecture makes easier is the maintenance of those seven and the consistency between them.

Resume where you left off, across CLIs

A long coding session rarely finishes in one sitting. You close the app, come back the next morning, and want to pick up the thread. Open Free Max 3.0 adds a multi-CLI resume picker for exactly this.

The resume picker lists prior sessions and lets you reopen them, and it does so across agents rather than for one favored CLI only. If your last session was in Claude Code, it is there. If it was in Gemini or Vibe, it is there too. Codex sessions are included through their rollouts, so a Codex conversation you started earlier can be brought back rather than restarted from an empty prompt.

This matters most when you work with more than one agent in a day. Without a cross-CLI picker, resuming would mean remembering which tool you used, launching it separately, and hoping it retained the thread. With the picker, the app remembers for you and presents the sessions in one place. You choose the one you want and it reopens in its own terminal, ready to continue.

The resume picker shipped on 2026-07-28, the same day Cursor Agent was added. Both are part of the current public release and both are available now on Windows and macOS.

The billing principle: your subscription, not an API meter

The most important design decision behind Open Free Max is not visible in the interface, but it shapes everything else. Open Free Max drives each official CLI in interactive mode, with a human in the loop. It does not call these agents through a headless, programmatic, or metered API path.

The consequence is straightforward. Because the app runs the official CLI the same way you would run it in a terminal, your usage stays on the subscription you already pay for, such as a Max or Pro plan tied to the agent's own login. Open Free Max does not open a second, metered billing channel behind your back. It does not turn an interactive session into a stream of API calls that bill per token on a separate invoice. You use the plan you already have, through the tool the vendor already ships.

Two boundaries follow from this, and both are deliberate. First, Open Free Max never handles your keys or your authentication. It does not store your credentials, it does not proxy your login, and it does not sit between you and the provider's auth server. Second, each official CLI manages its own subscription login on its own terms. When Claude Code needs you to sign in, you sign in to Claude Code. When Gemini needs authentication, Gemini handles it. Open Free Max orchestrates the terminals; the agents own their accounts.

This is why the release can describe itself as running official CLIs rather than reimplementing them. The agents are the real, vendor-shipped tools. The app is the command center that launches them, arranges their terminals, remembers their sessions, and keeps their settings straight. It stays out of the parts that belong to the provider, which is precisely the auth and billing that a middleman would otherwise touch.

A lightweight native app on Windows and macOS

Open Free Max is a native desktop IDE built with Tauri, Rust, and TypeScript. It is deliberately lightweight. Rather than bundling a heavy runtime or a browser stack you never asked for, it uses the platform's own webview and keeps the performance-sensitive work in Rust. The result is a small, fast application whose job is to host terminals and coordinate agents, not to reinvent an editor from scratch.

It runs on Windows and macOS. Both platforms get the same seven-CLI lineup, the same per-provider settings, and the same multi-CLI resume picker. There is no platform where one agent is present and another is missing; the release is the release on both.

The native choice is not cosmetic. Driving seven interactive terminals, each with its own PTY, benefits from a runtime that can manage processes and I/O efficiently. A Rust core handles that work, while the TypeScript front end renders the panes and the controls you interact with. You get a desktop tool that feels like a desktop tool, with the responsiveness that implies, and without the overhead of a full browser engine per window.

Who this is for

The seven-CLI command center is aimed at developers who already use more than one coding agent, or who want the freedom to. If you have a Claude subscription for one kind of work and a Codex or Gemini plan for another, you no longer switch tools to switch agents. You open one app and choose.

It is equally useful if you are still deciding which agent suits which task. Because all seven are available now and each runs in its own terminal, you can compare them directly on the same repository, in the same session view, without setting up seven separate environments. The app removes the friction of the comparison, and it does so without pushing you toward any one provider.

And it suits anyone who values the billing principle above. If you already pay for a subscription plan and want your agent usage to stay on that plan rather than spilling into a separate metered API bill, the interactive-mode design is the point. You keep the plan you have. The app does not reroute you.

What is available now, and what is not

Everything described in this article is available now in the current public release of Open Free Max, version 3.0, on Windows and macOS. All seven CLIs, the parallel PTY sessions, the schema-driven per-provider settings, and the multi-CLI resume picker including Codex rollouts are shipped features you can use today.

There is no limited or platform-specific carve-out among the seven agents. None of them is a beta hidden behind a flag, and none is exclusive to one operating system. The distinction the release draws is simple: this is what ships, and it ships whole.

What this article does not do is promise an eighth agent, a new platform, or a future capability. The generalized wiring and schema-driven settings make maintaining and extending the current set more tractable, and that is a fact about today's architecture rather than a roadmap. If and when anything changes, it will be announced as its own news when it is real, dated, and shipped, the same way Kimi Code, the multi-CLI wiring, and Cursor Agent were each announced as they landed.

Why one command center instead of seven tools

It is worth being explicit about the problem this release solves, because the value is easy to underrate until you have felt the friction it removes. When you use more than one coding agent, the cost is not only the money for each subscription. It is the mental overhead of context switching between tools that each behave slightly differently, each open in their own window, each with their own way of remembering what you were doing. You lose time to the seams between the tools, and you lose focus every time you cross one.

A command center collapses those seams. The seven agents live in one place, share one terminal-hosting model, and present their sessions through one resume picker. The friction of moving from one agent to another drops to the cost of clicking a different provider. You are still using the real, official CLI for each vendor, so nothing about the agents themselves is watered down, but the surrounding experience is unified in the ways that were previously scattered.

There is a second, quieter benefit. Because Open Free Max does not favor a single agent, it does not push you into a workflow that assumes one model is always the right answer. Different tasks suit different agents, and different developers have different subscriptions and preferences. A neutral command center respects that. It gives you the tools and gets out of the way, rather than steering every question toward whichever provider it happens to prefer. That neutrality is the whole reason the app can host seven agents without contradiction.

The seven agents, at a glance

The lineup spans four independent labs, one open-source project, and the tooling from two coding-focused vendors. Claude Code is Anthropic's official command-line agent. Codex is OpenAI's. Gemini is Google's. Vibe is Mistral's. Kimi Code is Moonshot's. OpenCode is an open-source agent CLI rather than a single vendor's product, which means it sits in the lineup as the community option alongside the vendor tools. Cursor Agent is the seventh, and the most recent addition, wired in on 2026-07-28.

Open Free Max does not rank these agents or claim one is better than another. It supports each one as its maker ships it, in interactive mode, through its own terminal. What the agent can do is the agent's story; what Open Free Max does is make sure you can reach all seven from one window, keep their sessions, and configure each with the settings it actually exposes. The app is the shared surface, and the agents keep their distinct identities beneath it.

That distinction is deliberate and it is the honest description of the release. Open Free Max is not a model. It does not add capabilities to Claude Code or Gemini or any of the others. It runs them, arranges them, and remembers them, and it does so for all seven equally.

A note on how sessions behave

Because each session runs in a real pseudo-terminal, the agent inside it behaves the way it would in a plain shell. Interactive prompts work. Progress output streams as it is produced. If the agent asks a question mid-task, you answer it in the pane, and the agent continues. Nothing about the terminal experience is simulated or flattened, which is why the app can support seven different agents without special-casing the quirks of each one's interactive behavior.

This fidelity is the reason the human stays in the loop, which is the same reason the billing principle holds. An interactive terminal is, by definition, a place where a person is present and responding. That is not an incidental detail. It is the mechanism that keeps usage on your existing subscription rather than turning your work into a metered stream of programmatic calls. The design and the billing outcome are the same fact seen from two angles.

Parallelism sits on top of that fidelity. Each terminal is genuinely independent, so running three or four agents at once does not force them to share a queue or a single prompt. You give each one a task, let them work, and check back on whichever finishes first, and the others carry on undisturbed while you do.

Getting started

Installation is a normal desktop install on either Windows or macOS. Once the app is running, you sign in to each agent through that agent's own login, exactly as you would if you launched the CLI by hand, because Open Free Max never handles those credentials itself. From there, you pick a provider, open a session, and start working in its terminal. To add a second agent, you open another session and choose a different provider; the first one keeps running.

When you return later, the resume picker shows your prior sessions across all the CLIs you used, so you reopen the one you want rather than starting over. Per-provider settings live with each agent, and because they are schema-driven, the options you see match what that particular CLI supports. None of this requires special configuration to unlock the seven agents; they are all present in the current release from the moment you install it.

How to get it

Open Free Max 3.0 is the current public release. To install it on Windows or macOS, go to the download page at /#download. If you want to read how the multi-CLI command center, the per-provider settings, and the resume picker work in detail before you install, the documentation lives at /docs.

Seven official coding-agent CLIs, one native window, on the subscription you already have. That is what the current release delivers, and every piece of it is available now.