Open Source Coding Agents That Use Existing Subscriptions 2026

Eight open-source coding agents now reuse a subscription you may already pay for. That changes Monday's decision from "which new seat should we buy?" to "which harness can safely spend the credits already on our books?"

OpenCode is the best overall choice because it has the broadest documented set of direct subscription routes: ChatGPT Plus or Pro, GitHub Copilot, GitLab Duo, and compatible SuperGrok or Grok plans. fx is the most interesting new alternative after adding direct Codex and Grok sign-in on August 21, 2026, but its own README still labels the project Experimental. goose is the best bridge when the subscription already lives behind Claude Code, Codex, Gemini, or Cursor and you want one extensible agent in front of it.

The business consequence is larger than a login convenience. A 10-person company on annual ChatGPT Business already has a $200 monthly plan line. A compatible open-source client adds $0 in recurring agent-client licenses. Ten new Cursor Teams Standard seats would add $400 per month, or $4,800 per year, before taxes and usage charges. The products are not feature-equivalent, but that $4,800 is the procurement question to answer before buying another layer.

At a glance

Prices and plan rules were checked on August 25, 2026. "Starting price" below is the agent client, not a promise of unlimited model use. The provider plan supplies inference and keeps its own caps, credits, data terms, and eligibility rules.

The ranking is not a feature-count contest. It starts with the plan already on the invoice, then asks how much control the developer needs during a run. If two tools can use the same subscription, the winner is the one whose permission and rollback model fits the repository.

The shortest direct paths are shown below. These are defaults, not the full compatibility map.

What the existing plans cost

Open-source clients have no software tier to upsell, so the live provider plan is the price wall.

For ChatGPT and Codex, OpenAI's current pricing is Free at $0 per month, Go at $8, Plus at $20, Pro 5x at $100, and Pro 20x at $200. Business is $20 per user per month for 2+ users when billed annually, or $25 when billed monthly. Enterprise and Edu require a sales quote. Not every third-party agent documents every one of those tiers, so each section below names only the route its maintainer supports.

For GitHub Copilot, the individual plan page lists Free at $0, Pro at $10 per user per month, Pro+ at $39, and Max at $100. Aider's documentation says calls flow through the user's Copilot subscription, but it does not promise that every tier exposes every model through the endpoint.

Google's Gemini CLI documentation publishes quota tiers rather than a second agent-client charge: 1,000 requests per user per day for Gemini Code Assist Individual, 1,500 for Google AI Pro, and 2,000 for Google AI Ultra. Workspace Code Assist Standard has 1,500 per day; Code Assist Enterprise and Workspace AI Ultra have 2,000. Those totals are also subject to per-minute limits and availability.

The phrase "use my subscription" therefore means authenticate against an included plan entitlement. It does not mean unlimited usage, a transferable seat, guaranteed access to every model, or freedom from the provider's terms.

How these were picked

This is a narrower list than a general open-source AI coding agents guide. A tool qualified only when its own current repository or documentation showed all of the following:

• The coding agent or agent harness has an MIT or Apache 2.0 codebase.
• It can inspect, edit, or run work in a codebase rather than only autocomplete a line.
• Its maintainer documents a route to a subscription a person or company may already own.
• The subscription route is distinct from entering a metered API key.
• The named limit is clear enough to tell a reader who should skip it.

The sources, prices, licenses, authentication flows, and limits were compared on August 25, 2026. The tools were not exercised in repositories during this run, so the evidence supports "compared" and "verified," never "tested." A screenshot shows the current product surface; it does not prove output quality.

Eight is a deliberate cut. Tools that were merely free to download, BYOK-only, proprietary, or wrappers around another authenticated agent did not make the ranking. The remaining depth goes to authentication, marginal cost, supervision, and the failure boundary.

The order uses four criteria:

1. Subscription breadth: How many existing plan families have a documented path?
2. Authentication clarity: Is there first-party OAuth or a fragile token workaround?
3. Control: Can a developer plan, approve, inspect, and reverse changes?
4. Operational maturity: Does the maintainer describe the project as stable, beta, or experimental?

That method puts OpenCode above fx even though fx's August release made the category newly relevant. A release can make a decision newly important without making the released tool the best default.

1. OpenCode: best overall for subscription choice

OpenCode is the best overall open-source coding agent for someone who wants to reuse a plan without committing the whole workflow to one provider. Its current provider guide documents zero-setup subscription use for ChatGPT Plus, GitHub Copilot, and GitLab Duo, plus device-code OAuth for eligible SuperGrok or Grok plans.

That breadth changes the rollout. A developer can start with the Copilot seat already assigned by an employer, switch to a personal ChatGPT plan for a different repository, or use a Grok entitlement without turning every choice into a new API billing account. The plan remains the economic unit; OpenCode becomes the replaceable interface.

The project is MIT licensed and offers a terminal client plus a beta desktop application. It also has a useful safety split. The built-in plan agent is read-only, denies file edits by default, and asks before Bash commands. The build agent has full development access. That creates a simple operating rule: map unfamiliar work in plan mode, then cross into build mode only after the proposed file and command scope is understood.

The most important OpenCode fact is also its best warning. Its provider guide says Anthropic explicitly prohibits plugins that use Claude Pro or Max models. OpenCode removed bundled versions of those plugins in version 1.3.0. Do not install a community workaround and call that subscription reuse. A public plugin is not permission from the plan owner.

OpenCode's xAI route is more direct. It opens xAI's device verification, stores the OAuth result after approval, and refreshes the access token automatically. Compatible SuperGrok, Grok, or X Premium plans that include Grok API access can work without a separate XAI_API_KEY. GitHub Copilot uses GitHub's device-code flow, while ChatGPT Plus or Pro opens a browser sign-in.

Best for: Developers with more than one compatible subscription, or organizations that want the agent interface decoupled from the model provider
Standout: The widest documented direct subscription selection among the eight verified agents
Pricing: $0 MIT client; an eligible ChatGPT, GitHub Copilot, GitLab Duo, or Grok-family plan supplies inference
Free trial: Not applicable to the open-source client

Set up OpenCode for a bounded pilot

1. 1

   Install only from the official source

   Use OpenCode's documented installer or package-manager route, then start it inside the one repository approved for the pilot. Keep unrelated parent directories and credentials outside the process.

2. 2

   Connect the plan already owned

   Run /connect, choose OpenAI, GitHub Copilot, GitLab, or xAI, and complete that provider's supported browser or device-code flow. Do not paste a metered API key when the purpose is to measure included subscription capacity.

3. 3

   Begin with the plan agent

   Use the Tab key to select the read-only plan agent. Ask it to map the change, name the files, propose commands, and identify tests before it receives edit access.

4. 4

   Cross into build mode deliberately

   Review the plan, create a disposable branch, then switch to the build agent for the approved change. Inspect the diff and test output before merging.

The choice flips away from OpenCode when the owned plan is clearly dominant and a first-party client removes useful ambiguity. A ChatGPT-only user should start with Codex CLI. A Google-only user should start with Gemini CLI. A team that wants to pass existing agents through a broader tool layer should look at goose.

2. fx: best lightweight Codex and Grok alternative

fx is the new release that changed this market. Vercel Labs added eligible Codex and Grok subscription sign-in in v0.0.5 on August 21, then shipped v0.0.6 on August 25 with fixes that keep those subscription sessions usable beyond 64 consecutive requests.

The workflow is deliberately small. fx login codex opens the Codex subscription route. fx login grok opens xAI. Inside fx, /setup changes the active provider and /model lists the authenticated catalog. The v0.0.5 release extended those sessions across interactive work, fx ask, ACP, images, subagents, and automatic reviews.

The credential path is concrete enough to audit. fx says the Codex OAuth token goes directly to OpenAI and is never sent to Vercel AI Gateway. The session lives at ~/.fx/chatgpt-auth.json and refreshes when needed. The Grok session goes directly to xAI, is not sent to Vercel AI Gateway or OpenAI, and lives at ~/.fx/grok-auth.json.

That makes fx attractive for a builder who already pays for both ecosystems. Instead of funding a third coding-agent account, the builder gets one Apache 2.0 harness and two plan-backed catalogs. The budget consequence is $0 for the client, not $0 for compute. Fast modes, credits, caps, and eligibility still belong to the underlying plan.

The reason fx ranks second rather than first is printed near the top of its own README: Status: Experimental. Use at your own risk. The project is a research-oriented harness written in Zig, not a mature procurement shortcut. The August 25 release fixed session longevity and sign-in recovery, but those fixes also show that the subscription path is still settling.

This is where the consequence law matters. The release is not valuable because OAuth is a shiny feature. It is valuable because a solo builder can challenge a duplicate subscription before paying it, and a platform engineer can prototype a provider-neutral harness without starting an API billing project. The same release is not yet a reason to replace an organization-wide standard on Monday.

Best for: Solo builders, agent researchers, and platform engineers who already have eligible Codex or Grok access
Standout: Direct provider switching between Codex and Grok subscription catalogs in a compact Apache 2.0 harness
Pricing: $0 client; an eligible ChatGPT or Grok subscription supplies inference
Free trial: Not applicable to the open-source client

Pick fx over OpenCode when the work is centered on Codex and Grok, the small harness is part of the appeal, and experimental software is acceptable. Pick OpenCode when the provider matrix or a more established daily-driver surface matters more.

3. goose: best subscription hub for cross-tool workflows

goose is the best choice when the subscription-backed coding agent is only one part of a broader workflow. The Apache 2.0 project has a desktop app for macOS, Linux, and Windows, a terminal client, and an embeddable API. Its repository documents 15+ model providers and 70+ MCP extensions.

goose treats another agent as a provider through Agent Client Protocol, or ACP. Its current documentation lists Claude ACP for an active Claude Code subscription, Codex ACP for ChatGPT Plus or Pro or API credits, and Cursor Agent for an authenticated Cursor subscription. It also offers a direct ChatGPT Codex provider with browser OAuth. The repository says existing Claude, ChatGPT, or Gemini subscriptions can be used through ACP.

This architecture has a practical advantage: goose can pass its extensions to the downstream agent as MCP servers. A subscription-backed coding engine can therefore sit behind a workflow that also queries a database, reads an issue tracker, or updates another system. The plan pays for the agent's inference; goose supplies the orchestration surface.

It also creates more joints that can fail. The downstream CLI must be installed and authenticated, the ACP adapter must be present, and the goose extension permissions need their own review. If a direct first-party agent can perform the whole job, placing goose in front adds flexibility at the cost of another protocol boundary.

That cost is worthwhile when the work crosses code and operations. It is less compelling for a developer who wants only a tight terminal pair-programming loop. The distinction matters because "supports my subscription" can hide two different implementations: a client that authenticates directly to the model provider, and a host that delegates to another authenticated agent. goose does both, but many of its subscription options use the second pattern.

The budget result is still favorable when the components are already owned. The goose client is free, ACP adapters are open, and the existing plan supplies inference. The operational result is not free. Someone must own upgrades, adapter compatibility, extension permissions, and the boundary between the host and downstream agent.

Best for: Builders whose coding session must also reach business systems through MCP, or teams standardizing several existing agent subscriptions behind one host
Standout: ACP turns authenticated Claude Code, Codex, Gemini, or Cursor agents into providers while preserving goose extensions
Pricing: $0 Apache 2.0 client; the connected Claude, ChatGPT, Gemini, Cursor, or other eligible plan supplies inference
Free trial: Not applicable to the open-source client

Choose goose when external tools are part of the job and the extra boundary earns its keep. Choose Codex CLI, Gemini CLI, or OpenCode when the goal is simply to edit and verify a repository with the shortest authentication chain.

4. Codex CLI: best direct use of a ChatGPT plan

Codex CLI is the cleanest answer for a person or company already committed to ChatGPT. OpenAI describes it as a coding agent that runs locally on the user's computer, publishes the client under Apache 2.0, and offers an official Sign in with ChatGPT route.

The first-party boundary is the value. There is no community OAuth adapter to evaluate and no separate gateway handling the credential. OpenAI explicitly recommends ChatGPT sign-in for Plus, Pro, Business, Edu, and Enterprise. Its broader pricing page also lists Free and Go access to Codex, while the repository's recommendation names the paid and organizational plans above.

That makes Codex CLI the lowest-friction pilot for a ChatGPT workspace. A company can choose one disposable repository, let an eligible user sign in through the supported flow, and measure whether included usage covers the work. No second agent seat is required for the client. No API key has to be issued just to learn whether the workflow is useful.

The hard wall is shared usage. OpenAI says Codex local messages and cloud chats on ChatGPT plans share a five-hour window, with possible additional weekly limits. A developer who spends the plan heavily in ChatGPT or Codex cloud can reach the same allowance from the CLI. Reusing a plan consolidates the budget, but it also consolidates the bottleneck.

API-key mode is not a workaround for that budget. OpenAI bills API-key use by tokens and says it does not include cloud features such as GitHub code review or Slack. It is a separate consumption model with a separate capability boundary.

The live plan ladder also prevents a common pricing mistake. As of August 25, Pro starts at $100 per month for the 5x tier, while the 20x tier is $200. Plus is $20. Business is $20 per user per month on annual billing for at least two users, or $25 monthly. An article that calls every Pro seat $200 is now stale.

Best for: ChatGPT users who want the provider's own local coding agent and the shortest supported auth path
Standout: First-party ChatGPT sign-in with no third-party subscription adapter
Pricing: $0 Apache 2.0 client; ChatGPT Free $0, Go $8, Plus $20, Pro $100 or $200, Business $20 annual or $25 monthly per user, Enterprise and Edu custom
Free trial: No client trial required; ChatGPT Free is the $0 entry tier

Choose Codex CLI over OpenCode or Cline when a first-party path is more valuable than provider choice or a richer approval interface. Choose OpenCode when the existing subscription may change. Choose Cline when visible per-action approval is the operating requirement.

For a broader first-party comparison, the decision boundaries between Codex, Claude Code, and Cursor are covered in Codex vs Claude Code vs Cursor.

5. Gemini CLI: best for an existing Google plan

Gemini CLI is the best open-source coding agent when the useful entitlement already sits in a Google account or Workspace plan. The Apache 2.0 terminal agent supports Google OAuth, so the user signs in rather than managing a Gemini API key.

Google publishes the clearest fixed quota ladder among these agents. Gemini Code Assist Individual includes up to 1,000 model requests per user per day. Google AI Pro raises that to 1,500, and Google AI Ultra to 2,000. Workspace Code Assist Standard includes 1,500; Code Assist Enterprise and Workspace AI Ultra include 2,000.

Those numbers make capacity planning easier than a vague "generous use" promise. A solo developer with a personal Google account can begin at $0. Someone already paying for Google AI Pro or Ultra can use the higher allowance without adding another agent-client line. A Workspace administrator can map the documented Code Assist tier to a daily ceiling before a rollout.

The daily number is not a throughput guarantee. Google's quota document says requests are also limited per user per minute and remain subject to availability. It also says model requests are made across the Gemini family as determined by Gemini CLI. A 2,000-request allowance does not grant the user a permanent claim on one exact model.

The API-key free tier is a different path. It allows 250 requests per user per day and Flash models only. That may be useful for a script, but it is not the same as reusing the Google-account entitlement. Keep OAuth and API billing separate in the pilot report so a free API allowance is not mistaken for plan reuse.

Inside a Google-first organization, Gemini CLI moves above Codex CLI. The account system, quota documentation, and open client align cleanly, and there is little reason to buy another interactive coding seat before measuring this path.

Best for: Developers and organizations already paying for Google AI Pro, Google AI Ultra, or a supported Workspace Code Assist tier
Standout: A published daily quota ladder from 1,000 to 2,000 requests per user, depending on the entitlement
Pricing: $0 Apache 2.0 client; Google-account and supported fixed-price plan entitlements supply inference
Free trial: No client trial required; Code Assist Individual is the $0 entry path

Choose Gemini CLI when Google already owns the budget line. Choose OpenCode or goose only if cross-provider portability or external-tool orchestration is worth adding another layer.

6. Cline: best approval-first IDE and CLI path

Cline is the best subscription-reusing option for developers who want the agent's proposed edits and commands kept visible. Its shared agent core powers a CLI, VS Code extension, SDK, and Kanban workflow, and its Plan and Act design can require approval for every file edit and terminal command.

The CLI documents a ChatGPT Subscription route through the openai-codex provider. It supports interactive chat, one-shot prompts, JSON output, headless execution, and a background mode. Plan and Act, MCP servers, checkpoints with /undo, subagents and teams, schedules, and chat connectors share the same core.

That makes Cline more than a terminal wrapper. A developer can plan with approvals, work inside VS Code, then use the same rules and provider configuration from the CLI. The subscription route removes the OpenAI API key from that flow. Most of Cline's other listed providers still require their own API keys, so "model agnostic" should not be read as "subscription compatible with every model company."

The approval model is the reason to choose it, not the number of surfaces. A pilot can begin with auto-approve disabled, require a human decision at each tool call, and use checkpoints to reverse the workspace state. Once the command classes and repository boundaries are understood, selective automation becomes an informed policy change rather than the default.

There is one source boundary to note. The main repository says the shared core, CLI, VS Code extension, SDK, and Kanban code are Apache 2.0, but the JetBrains plugin is not open-sourced. A JetBrains user may still use the product, but an open-source-only procurement claim should describe that exception.

The broad feature set can also outrun the narrow goal. Schedules, connectors, headless mode, and subagents create useful automation paths, but each one changes who can initiate work and what the agent can reach. Do not enable them merely because the client license is free.

Best for: Developers who want ChatGPT-backed coding with visible approvals, diffs, checkpoints, and a choice of IDE or terminal
Standout: Plan and Act supervision plus a shared agent core across interactive and automated surfaces
Pricing: $0 for the Apache 2.0 open-source core; an eligible ChatGPT subscription supplies the openai-codex route
Free trial: Not applicable to the open-source core

Choose Cline over Codex CLI when supervision and IDE continuity matter more than the shortest first-party chain. Choose Codex CLI when an official OpenAI client is the stronger control. Choose Kilo Code when the IDE mix includes JetBrains and message-level rollback is the deciding feature.

7. Kilo Code: best multi-surface alternative

Kilo Code is the strongest alternative for a developer who wants one open-source agent across VS Code, JetBrains, and the terminal. Its MIT repository documents those three surfaces, while its authentication guide supports ChatGPT Plus or Pro through browser sign-in with no API key.

Kilo's broader catalog needs careful reading. The repository advertises 500+ models with mid-task switching and provider-rate pricing with zero markup through a Kilo account. The authentication guide says Kilo supports over 30 providers. Those numbers describe the whole provider and gateway surface, not 500+ models funded by one ChatGPT subscription.

Kilo's qualifying subscription path is narrower: ChatGPT Plus or Pro through the OpenAI ChatGPT provider. Other providers may require an API key, a Kilo balance, or their own account flow. That distinction prevents an attractive model count from becoming a false budget promise.

Kilo's most useful control is its snapshot system. The new extension enables snapshots by default and stores them in a dedicated Git repository outside the project, so the project's own Git history is not modified. Snapshots are captured around model-call boundaries, but the revert interface operates at the user-message level. It cannot roll back one intermediate step or one file inside a multi-step response.

That named limit is more useful than a generic claim about safe AI. A developer knows that one prompt is the recovery unit. The Monday pilot can therefore keep prompts small, inspect the changed-file summary after each one, and preserve manual Git commits as the higher-level audit trail.

Kilo ranks below Cline because its current subscription-reuse documentation is narrower than its provider catalog and its product surface is broader. It moves above Aider when native IDE support and browser login matter more than a Git-first terminal loop.

Best for: Developers moving between VS Code, JetBrains, and the CLI who already own ChatGPT Plus or Pro
Standout: Default snapshots outside the project Git history, plus message-level revert
Pricing: $0 MIT client; the documented direct subscription path requires ChatGPT Plus or Pro
Free trial: Not applicable to the open-source client

Choose Kilo Code when IDE coverage and message-level rollback are the two requirements. Choose Cline for a stronger approval-first posture. Choose OpenCode when subscription breadth matters more than IDE breadth.

8. Aider: best Git-first Copilot bridge

Aider is the best Git-first option for a developer who already pays for GitHub Copilot and accepts a manual credential setup. The Apache 2.0 terminal agent maps the codebase, edits files, and automatically commits its changes with descriptive commit messages.

Aider's own guide says it can use GitHub Copilot's OpenAI-style endpoint and that calls made through Aider are billed through the user's Copilot subscription. That is a genuine subscription path, but it is the least polished authentication flow in this ranking.

The documented setup begins by signing in to Copilot from a JetBrains IDE. The user then retrieves the OAuth token from the Copilot configuration file, assigns it to OPENAI_API_KEY, and points OPENAI_API_BASE at https://api.githubcopilot.com. Aider also warns that tokens generated by the Neovim copilot.lua plugin can lack the necessary scopes.

The variable name is misleading in this configuration. It carries a Copilot OAuth token, not an OpenAI platform key. That increases the chance of copying a credential into the wrong shell history, dotfile, or support ticket. Treat it as a secret, scope the environment to the Aider process, and prefer a credential manager over a globally exported value.

Once connected, the workflow is unusually clear. Aider works inside Git, records changes as commits, and lets familiar diff and undo tools remain the control plane. The person who already uses Aider and already pays for Copilot gets a way to consolidate model billing without changing the pair-programming loop.

The friction is why Aider ranks eighth, not because the agent is weak. OpenCode offers a normal GitHub device flow for Copilot. Aider's manual token extraction earns its place only when Aider's Git behavior is the feature being protected.

GitHub's individual plans were also checked on August 25: Free is $0, Pro is $10 per user per month, Pro+ is $39, and Max is $100. Aider does not promise equal model access through every tier, so the safe statement is that calls are billed through the connected subscription and the available model list comes from that account.

Best for: Existing Aider users who want to keep its automatic Git workflow and route model calls through GitHub Copilot
Standout: Subscription-backed inference without abandoning Aider's commit-centered terminal loop
Pricing: $0 Apache 2.0 client; GitHub Copilot Free $0, Pro $10, Pro+ $39, and Max $100, subject to account model access
Free trial: No client trial required; Copilot Free is the $0 provider entry tier, but endpoint access varies by entitlement

Choose Aider over OpenCode only when its automatic Git commits and focused terminal loop outweigh the authentication friction. For a new Copilot-backed setup, OpenCode is the cleaner starting point.

Who should pick what

The explicit decision rule is simple: start with the subscription already approved, then choose the narrowest client that provides the required supervision. Provider breadth comes third. Feature count comes last.

If the company owns ChatGPT, choose Codex CLI for the shortest first-party route. Move to Cline when visible approvals and IDE work are necessary. Move to Kilo Code when JetBrains plus snapshots matter. Pick OpenCode when the possibility of moving to Copilot, GitLab Duo, or Grok is worth a provider-neutral harness. Pick fx only when Codex and Grok are the intended pair and experimental software is acceptable.

If the company owns a supported Google plan, choose Gemini CLI. Its account sign-in and published daily caps make the pilot easy to define. goose earns the extra layer only when the coding agent must also use MCP extensions or fit into a larger operational workflow.

If the company owns GitHub Copilot, choose OpenCode for the clean device-code path. Choose Aider when the existing workflow already depends on automatic Git commits. The decision flips toward Aider because of workflow continuity, not because its authentication is better.

If the company owns Grok or SuperGrok, choose fx for the smallest Codex-and-Grok harness or OpenCode for a wider provider future. fx is the sharper experiment; OpenCode is the safer general default.

If the company owns Claude Code or Cursor, choose goose when ACP orchestration and MCP extensions provide a concrete benefit. This is delegation through an authenticated downstream agent, not direct model-provider OAuth inside goose, so include the adapter in the threat model and support plan.

The cost figure is a budget screen, not a product equivalence claim. Cursor Teams includes centralized administration, shared context, privacy controls, and other managed features that a free client does not recreate. The point is to make those differences earn the extra $4,800 rather than assume another seat is necessary.

The Monday move: run a one-repository pilot

Do not begin with an organization-wide tool vote. Begin with one repository, one eligible user, one recurring task, and one week of evidence.

1. 1

   Confirm the entitlement and the terms

   Write down the exact plan, account owner, supported authentication method, renewal price, and usage cap. Reject community workarounds that the provider does not permit.

2. 2

   Choose the narrowest qualifying agent

   Use Codex CLI for ChatGPT, Gemini CLI for Google, OpenCode for Copilot, or fx for a Codex and Grok experiment. Add Cline, Kilo Code, Aider, or goose only when their control or orchestration model solves a named need.

3. 3

   Isolate one repository

   Create a disposable branch, remove unrelated credentials from the process, and keep production deployment access out of scope. Start in a read-only or approval-required mode when the client offers one.

4. 4

   Measure the budget and the work

   Record plan-limit warnings, additional credits, completed tasks, human review time, changed files, test results, and reversions. A $0 client that consumes scarce plan credits or review hours can still be the expensive choice.

5. 5

   Make the seat decision

   Keep the open-source path when included usage covers the workload and the permission model fits. Buy a managed seat only when its administration, capacity, collaboration, or support closes a measured gap.

This pilot gives procurement a counterfactual. The question is no longer whether a popular coding agent looks useful. It is whether the paid alternative closes a gap the owned subscription and open client could not close.

The ones to avoid

Some strong products should be excluded from this particular shortlist, and some tempting routes should be refused.

Avoid Claude Pro or Max plugins for OpenCode. OpenCode's own provider guide says Anthropic explicitly prohibits them and removed the bundled plugins in version 1.3.0. The client being open source does not make an unsupported authentication route acceptable.

Do not call Claude Code open source. Claude Code can use an existing Anthropic subscription and may be the right proprietary tool, but its repository license says all rights reserved and subjects use to Anthropic's Commercial Terms. It fails the open-license rule in the query. The broader best AI coding agents guide is the place to compare proprietary and open clients together.

Do not choose OpenHands for direct subscription reuse alone. OpenHands Agent Canvas is an MIT self-hosted control center that can run Claude Code, Codex, Gemini, and other ACP agents. Its current README describes those as third-party backends. That can be useful orchestration, but it is not the same as the OpenHands agent directly authenticating to a consumer plan. Choose it for control-center and automation needs, not to avoid one model bill.

Do not standardize fx across a company while ignoring its Experimental label. fx belongs in a bounded pilot because the new Codex and Grok path is consequential. The same evidence does not support unattended production or a broad mandate yet.

Finally, reject any "free" label on a BYOK client that omits the model bill. A $0 repository and a metered API account are two separate budget lines. Only vendor-documented subscription reuse passes the inclusion rule; API-key paths remain a separate purchase.

FAQ

Are there free open-source coding agents that use existing subscriptions?

Yes. OpenCode, fx, goose, Codex CLI, Gemini CLI, Cline, Kilo Code, and Aider all have $0 open-source clients plus at least one documented existing-plan route. The provider subscription still enforces eligibility, credits, quotas, and data terms.

Which is the best open-source coding agent?

OpenCode is the best general answer for subscription breadth. Codex CLI is better for a ChatGPT-only setup, Gemini CLI for a Google-first setup, and Cline when per-action supervision is the primary requirement.

What is the best local coding agent model?

The agent and the model are separate decisions. Select the harness and subscription path first; the best model depends on repository language, task type, plan catalog, latency, and limits. Start with the model included in the owned plan and evaluate it on one representative task.

Get the AI Business Workflow Audit Checklist and the next evidence-led build guide by joining the newsletter.