Choosing AI Provider Plans

CoderFlow runs tasks using your own accounts with AI providers — Claude (Anthropic), Codex (OpenAI), Gemini (Google), Bob (IBM), Grok (xAI), and Kimi (Moonshot AI). Before rolling out CoderFlow to a team, you need to decide which accounts to purchase, how many, and how to structure them. This page gives a decision framework; for the mechanics of connecting accounts, see AI Provider Authentication.

Note: Vendor plan names, prices, and usage limits change frequently. This page focuses on the decisions that stay stable; always confirm current details on the vendor's pricing page before purchasing.

Two Ways to Pay

Every provider offers two fundamentally different purchasing models, and CoderFlow supports both:

• Subscription accounts (flat monthly fee) — You sign in to CoderFlow with the provider account via OAuth, and usage draws from the subscription's included allowance. With steady daily use, subscriptions are almost always the better value: a developer working with agents throughout the day would typically spend several times the subscription price at metered API rates.
• API keys (pay per token) — Usage is metered and billed per token with no fixed ceiling. API keys are the right fit for spiky or unattended workloads, for overflow capacity when subscription limits are exhausted, and for shared service-style access, since API keys are the mechanism vendors design for automated and multi-user use.

Most teams land on a combination: subscriptions for the day-to-day agent workload, plus at least one API key per provider for overflow and for CoderFlow's API-backed helper features (automatic task naming and setup-repository commit-message generation), which require an API-key account.

Step 1: Inventory What You Already Have

Start with the accounts your company already pays for — they may already cover part of the need:

• Claude Team or Enterprise — If your company already has a Claude Team plan, check the seat types: Premium seats include Claude Code (the agent CoderFlow runs); Standard seats do not. Upgrading existing seats to Premium is usually simpler than buying separate individual plans, and keeps billing and administration in one place.
• ChatGPT Business or Enterprise — Business seats include Codex access. OpenAI also offers usage-based Codex-only seats for people who don't need the chat product.
• IBM Bob — Bob access comes through your IBM arrangement and IBM w3id sign-in; there is no separate consumer tier to purchase.
• Existing individual subscriptions — Developers who already have personal-tier accounts can connect them as per-user accounts (see Step 2), though for company use the accounts should be company-owned and company-paid.

Also confirm that existing accounts belong to the actual people who will run CoderFlow tasks, on your company's email domain — that matters for the next step.

Step 2: Choose an Account Topology

CoderFlow can hold provider accounts at two levels, and they compose (see AI Provider Authentication for setup):

• Server-level (global) accounts — One set of accounts the whole installation runs on. Simplest to administer, and works with CoderFlow's round-robin feature to pool multiple accounts. The tradeoff: all users draw from the same usage allowance, so one heavy user can exhaust the window for everyone.
• Per-user accounts — Each developer signs in with their own subscription. Capacity scales naturally with headcount, usage is attributable per person, and it matches vendor terms of service, which may require accounts to belong to a named individual.
• Mixed — The two levels combine per person, not per task: when a user launches a task, CoderFlow uses that user's own account for the provider if they have one, and the server-level account only if they don't. A user's account wins even when its usage window is exhausted — CoderFlow does not fall back to the server-level account mid-stream. So think of server-level accounts as covering the people (and automations) who haven't connected their own account, not as backup capacity for those who have.

Step 3: Pick Subscription Tiers

For agent workloads, entry-level tiers run out quickly. General guidance per provider:

Provider	Start with	Step up to	Notes
Claude (Anthropic)	Max 5x, or Team Premium seats	Max 20x	Max tiers are named for their usage multiple over Pro; the 20x tier is the strongest value for heavy use. Team Standard seats do not include Claude Code.
Codex (OpenAI)	Plus	Pro	Business seats carry Plus-level Codex limits; credits can extend past included limits.
Grok (xAI)	SuperGrok	SuperGrok Heavy	SuperGrok includes the Grok coding agent. xAI has no team plan; business-grade access is via API key.
Gemini (Google)	Google AI Pro	Google AI Ultra	Personal Google accounts connect via OAuth.
Kimi (Moonshot AI)	Kimi Code plan	Higher Kimi Code tiers	Eligible Kimi Code plans unlock the extended context window.

Two workload patterns to size around:

• Variant generation is the heavy load. Providers whose agents you run in multi-variant task groups consume the most usage — size those subscriptions highest.
• Judges are light. If a provider's role is mainly to act as the judge comparing other agents' work, its base agent-capable tier is usually enough. A judge task consumes the account like any other task, but judging runs are shorter and less frequent than generation runs. Judge tasks cannot be routed to a separate account within the same provider — so if you want judging to draw on a separate budget from generation, use a different provider as the judge. Many teams do exactly this: generate with two or three agents, and judge with a vendor that isn't generating.

Step 4: Size the Number of Accounts for Concurrency

Subscription limits are per account, typically as a rolling-window allowance plus weekly caps. If your team runs many concurrent tasks, a single account per provider will throttle regardless of tier. CoderFlow's answer is the round-robin pool: register multiple subscription accounts for a provider and CoderFlow spreads concurrent tasks across them.

A practical sizing approach:

1. Estimate peak concurrent tasks per provider (developers × typical parallel variants).
2. Start with one top-tier account per 1–2 heavy users (or the per-user topology, which achieves the same scaling).
3. Watch for tasks pausing on usage limits during your first weeks; add accounts to the round-robin pool — or raise tiers — where a provider is the bottleneck.
4. Keep an API-key account ready so that when subscription windows are exhausted, you can switch the provider's active account to the API key and continue at metered rates. Note that switching is a deliberate step — CoderFlow does not fail over to another account automatically when limits are hit.

Quick Recommendations

• Small team evaluating CoderFlow — One top-tier subscription for your primary agent, entry agent-capable tiers for secondary and judge agents, one API key for helper features. Server-level accounts are fine at this size.
• Team rollout — Per-user subscriptions for each developer (or Team/Business seats if you already have them), server-level accounts for any users or automations without their own, judges on base tiers — ideally on a provider that isn't generating.
• Heavy automation and batch work — Expect subscription windows to be the constraint. Use round-robin pools of multiple accounts, and budget for API-key overflow as part of the plan rather than an exception.