Every developer who opens Influxx for the first time has already made an AI choice. They're paying for Claude Code, or Codex, or Cursor, or Copilot, or some combination of Grok, Gemini, and a dozen others — a subscription or an API key they use daily, independent of any app we build. So the question we had to answer before writing a line of onboarding copy wasn't how to sell AI credits; it was whose bill a new worktree runs on by default. Influxx's answer is that it isn't ours: bring your own CLI runs free of any Influxx gateway billing, by design, while managed chat stays the option you reach for, not the one you have to opt out of.
Why Bring-Your-Own Had to Be the Default
Influxx orchestrates more than 30 coding-agent CLIs — Claude Code, Codex, Cursor, GitHub Copilot, Gemini, Grok, Droid, Amp, OpenCode, and a long tail of others — each running in its own isolated git worktree, with notes and terminal living side by side in one cockpit window. Every one of those CLIs already comes with its own authentication story before Influxx enters the picture at all: a Claude subscription, a Codex account tied to a ChatGPT plan, a Copilot seat through GitHub, an API key sitting in a provider's dashboard. That's the fact our product philosophy has to start from, not work around.
Internally we call that philosophy dual intelligence, and it names two paths on purpose, ranked in a specific order. The first is bring-your-own-CLI: your local agent runs in an isolated worktree PTY, authenticated with whatever you already have, and none of that traffic touches an Influxx-run gateway or bill. The second is managed chat: an optional path that routes through a managed AI gateway, for developers who'd rather pay in credits than manage their own CLI accounts. Both are real, supported products. Only one of them is the default — and it's not the one that generates revenue on every request.
"We build orchestration software, not a toll booth. A working developer already has a coding-agent subscription; the value we add is the cockpit that coordinates it across a dozen worktrees, not a markup on tokens they'd be spending anyway."
— Sofia Reyes, Head of Product at ETAPX
What "Free of Gateway Billing" Actually Means
"Free" is doing precise work in that sentence, so it's worth being literal about what it covers and where it stops.
Your Worktree Runs Your CLI, Not Ours
When you open a tab in Influxx and point it at Claude Code, Codex, or any other supported CLI, Influxx starts that CLI's actual binary inside an isolated git worktree, wired to a PTY the same way any terminal session would be. The requests that CLI makes still go exactly where they always went: Anthropic's API under your Claude subscription, OpenAI's under your Codex or ChatGPT plan, GitHub's under your Copilot seat. Influxx never inserts itself into that request path as a paid intermediary. Our job is coordinating which worktree the terminal is isolated to and how its output sits next to your notes — not re-billing tokens you're already paying for somewhere else.
Managed Chat Is Where Our Billing Starts
Managed chat is a different lane entirely, and it's the only one where Influxx billing applies. Choose it, and your conversation routes through a managed AI gateway that Influxx operates, paid for in credits instead of through a CLI subscription you bring yourself. That path exists deliberately and openly — it's just something you have to reach for. Nothing about opening a new worktree nudges you toward it by default.
- Bring-your-own CLI: Runs your local agent's own binary in an isolated worktree PTY, authenticated by your existing subscription or API key, free of Influxx gateway billing by design.
- Managed chat: Routes through the managed AI gateway Influxx operates, billed in credits, for developers who'd rather pay for convenience than configure their own CLI accounts.
"I already pay for a Claude subscription and a Copilot seat through work. Before I moved my whole workflow into Influxx, I checked whether it was going to meter my Claude usage on top of what I already pay Anthropic. It doesn't — it just runs Claude Code in a worktree the same way I'd run it in a plain terminal myself. That's the whole pitch for me."
— Devon Marsh, contract backend engineer running Influxx across three client codebases
The Internal Rule: Prefer BYO, Managed Is Optional
Every product has a natural gravity toward whatever is easiest to meter. If a growth roadmap needed an easy lever, the obvious one would be quietly nudging every new worktree toward managed chat, where usage is visible and billable end to end. We wrote down a rule specifically to resist that gravity: prefer the bring-your-own-CLI path; managed is optional, paid, and never something a developer has to argue their way out of.
That rule shows up in unglamorous places. It's why picking a CLI is the first thing a new worktree asks, ahead of any prompt to buy credits. It's why the settings screen for adding a Claude or Codex account sits next to the managed chat option, not underneath it as a lesser alternative. It's why nothing in onboarding treats an existing subscription as a problem that switching to Influxx billing would solve. A rule like this is easy to write down and easy to quietly erode one small decision at a time — a slightly more prominent upsell here, a default that assumes managed there. The discipline is remembering it's a rule at all, every time someone proposes a change that would nudge the number up.
Managed Chat Isn't a Downgrade — It's a Different Developer
None of this makes managed chat a lesser product, or a bait-and-switch waiting to happen once we've got you hooked on the cockpit. It's built for a real, different developer than the one bring-your-own assumes.
- No existing subscription: Someone evaluating Influxx who hasn't already signed up for Claude, Codex, or Copilot, and doesn't want to go set one up before deciding whether the cockpit fits their workflow.
- Simplicity over setup: Someone who'd rather not track which of six provider accounts is authenticated where, and is fine paying in credits for not having to think about it.
- Team provisioning: A team where handing every contractor their own individually billed CLI subscription is more overhead than drawing from one shared, metered pool.
Bring-your-own has a precondition managed chat doesn't: you have to already have something to bring. In that case Influxx's job flips entirely. Instead of getting out of the way of a subscription you already pay for, it has to be the whole path — gateway, billing, and all. Both jobs are legitimate work for us to do. They're just not the same developer, and defaulting to the path that fits more of the people who already have thirty-some CLIs installed somewhere on their machines is the more honest place to start.
The Unsexy Infrastructure Behind "Just Bring Your Own"
It would be easy to assume bring-your-own-CLI means Influxx shells out to a binary and otherwise stays out of the way. In practice, supporting it properly turned out to be some of the least trivial infrastructure in the product. Professional developers don't run a single Claude account or a single Codex account — they run several, split across a personal subscription, a work seat, and sometimes a client's. Influxx has to let someone switch which account a worktree is authenticated as without corrupting whatever that terminal's CLI process currently believes about its own auth.
Switching Accounts Without Corrupting a Live Session
That requirement turns into real machinery, not a settings toggle:
- Credential materialization: the right credentials for the account you just switched to have to be written into place before the CLI process looks for them.
- Session gating: a switch can't be allowed to land mid-request into a terminal where an agent is already running, or it hands a live process half-updated auth.
- Per-worktree isolation: one tab's account switch can't bleed into another tab's session, even when both are running the same CLI.
Claude and Codex each have their own version of this managed-account handling, because the two CLIs' auth models are different enough that a shared abstraction would paper over real differences instead of handling them properly.
"The hard part was never launching a CLI in a worktree — that's a PTY and a working directory. The hard part is that a developer can switch which Claude account a tab is authenticated as while an agent is mid-task in that same tab, and we have to gate that switch so it lands cleanly instead of handing a running process half-updated credentials."
— Daniel Kwon, Staff Engineer, Agent Orchestration at ETAPX
We didn't build that gating because managed chat needed it — managed chat's authentication is ours to control end to end, on our own gateway. We built it because bring-your-own is the default, and a default that only worked cleanly for a developer with one account on one provider wouldn't have matched how professional developers actually work.
Where We're Actually Planning to Charge
None of this means Influxx has no business model — it means the business model has to sit downstream of the default, not upstream of it. The direction we're building toward pairs a seat-based fee with usage credits, and it applies to the managed path: the gateway Influxx operates, the convenience of not configuring your own provider accounts, the option you choose instead of a CLI you already have running somewhere. We haven't finalized pricing, and we're not going to guess at a number in an article that would outlive the number.
What we can say plainly is the scope. Bring-your-own-CLI doesn't carry gateway billing as an introductory rate that quietly expires once we've got you using the product regularly. It's free of that billing because the request never routes through anything Influxx meters in the first place. There's no future version of Influxx where a Claude Code session running in your own worktree, under your own subscription, starts accruing an Influxx-metered cost — the architecture simply doesn't route it through anything we'd charge for. If that ever changed, it wouldn't be a pricing update. It would be a different product.
Frequently Asked Questions
Does Influxx charge anything on top of my existing Claude Code or Codex subscription?
No. When you run a CLI through bring-your-own, Influxx starts that CLI's own binary in an isolated worktree and lets it authenticate exactly as it would in a plain terminal — your subscription or API key is billed by the provider, not by Influxx. Influxx doesn't sit in that request path as a paid gateway.
What is managed chat, exactly, and who is it for?
Managed chat is the alternative path: instead of running your own CLI, you chat through a gateway Influxx operates and pay in credits. It's built for developers who don't already have an agent subscription, or who'd rather not manage provider accounts and are fine paying for that convenience.
Can I use bring-your-own CLI and managed chat in the same project?
Yes — they're not mutually exclusive. You might run Claude Code in one worktree on your own subscription and open a managed chat tab in another for a quick question, without setting up a separate provider account for it. The cockpit treats both as tabs in the same window.
How does Influxx handle switching between multiple accounts for the same provider?
Influxx has dedicated account-switching handling for providers like Claude and Codex, since professional developers often run more than one account per provider. Switching materializes the right credentials for the account you selected and is gated so it can't corrupt a CLI process that's already mid-session in a live terminal.
Will bring-your-own CLI ever start costing more, or is this an introductory rate?
It's free of Influxx gateway billing by design, not as an introductory offer. The bring-your-own path doesn't route through anything Influxx meters, so there's no mechanism for that to quietly change later; any future pricing work applies to the managed path, not this one.
How much will managed chat cost?
We're building toward a model that pairs a seat-based fee with usage credits, scoped entirely to the managed path. We haven't finalized or published specific pricing yet, so we're not going to put a number here that we'd have to walk back later.
Bring-your-own CLI is the default because most developers who open Influxx for the first time already made their AI choice long before they found us — Claude, Codex, Copilot, or all three, already paid for and already part of how they work. Our job is making thirty-some of those tools cooperate in one cockpit without charging anyone twice for the privilege. Managed chat stays exactly where it belongs: available, credited, and entirely optional.
