Together Link Lets Your Coding Agent Run On Open Models: One Command, Half The Bill

Posted on by
Contents show
A flat vector illustration of a terminal window in dark charcoal with three thin teal wires flowing out to three small app icons and a small amber coin above the window, representing Together Link connecting your coding agent to open models

The economics of coding agents have a structural problem: the harnesses developers love are priced around the closed frontier models they were built for, and running every session on a top-tier API model can push a team's monthly bill from hundreds of dollars into the thousands. Together AI's answer, released 5 October 2026, is Together Link: a free, open-source command-line tool that connects the coding agents teams already use, Claude Code, Codex, OpenCode, Claude Desktop, ChatGPT Desktop and Pi, to open models on Together's serverless platform, with an auto router that picks the model once per session and a claim of cutting agent spend by over 50 percent. Together Link is in beta, MIT-licensed, and answers a question this site has been tracking all autumn: now that open models handle real coding work, what is the plumbing that lets working developers actually choose them?

The claim deserves scrutiny, and the product page supplies enough detail to evaluate it. This article works from Together's own Link page and announcement materials, read directly: what the tool actually changes and preserves, how the router decides, where the savings come from and what the 50-to-80-percent figure does and does not mean. It extends this site's running coverage of inference economics, from model routing to inference caching, because Together Link is the consumer-facing expression of the same idea: route work to the cheapest model that can do it, and stop paying frontier prices for routine tasks.

What it changes, and what it deliberately does not

Together Link is a proxy layer, not a new agent, and that distinction drives everything about how it behaves. One command installs it; a per-agent command, such as togetherlink claude, launches the familiar tool with its traffic translated to Together's endpoint. The design principle is explicit on the product page: your login, settings, history and habits stay exactly where they are.

What that means per harness, from Together's own documentation: Claude Code keeps its login and subscription, its settings, memory and history, and even web search via an optional Exa key. Codex runs on its own profile with the ChatGPT sign-in, config, AGENTS.md and history preserved, switched off with a single command. Claude Desktop and ChatGPT Desktop install reversible profiles rather than touching existing settings. OpenCode and Pi, which already support multiple providers, simply gain the Together models in their model lists. Nothing is migrated, nothing is locked in, and the uninstall is one command.

That reversibility is Together Link's real design achievement. Agent tooling adoption usually fails on switching costs, new interfaces, new settings, new habits. Together Link's bet is that the only thing that needs to change is which model answers the request, and that everything else, the harness, the muscle memory, the project context, stays untouched.

The router: one decision per session, on purpose

The auto router reads the first task in each session and routes accordingly: quick work goes to a low-cost model, hard problems go to a more capable one. With an Anthropic API key present, it routes between Opus 5.5 and GLM 5.3; without one, between GLM 5.3 and GLM 5.3 Flash.

The design constraint that makes this clever is prompt caching. Routing decisions that change mid-session break the cached prefix, because a different model's context is a different cache. By deciding once per session, Together Link keeps prompt caching working for the whole interaction, which is where the real savings compound: cached tokens are billed at a fraction of fresh-input prices, as this site's caching coverage has detailed, and a session that switches models every few turns would forfeit that discount entirely.

The model lineup spans the pricing ladder: Kimi K3 at 3.00 dollars per million input tokens and 15.00 output, GLM 5.3 at 1.40 and 4.40, and MiniMax M3 and DeepSeek V4.1 Flash at 0.30 and 1.20. Together Link surfaces these in the agent's own model menu, so picking a specific model instead of Auto is a menu selection, and the open-model quality behind those prices is documented in this site's release coverage, from Kimi-class models to the routing logic that pairs them. Against closed frontier pricing, the open models run at a fraction per token, which is the raw material the savings claim is made of.

The savings claim, taken seriously

Together states the savings as over 50 percent on the product page and, in its FAQ, as 50 to 80 percent compared with running every session on Opus 5.5. The range is honest in a way marketing rarely is, because the spread is arithmetic: sessions that the router sends to a 0.30-dollar model instead of a premium one save far more than sessions routed to GLM 5.3, and a team whose traffic is genuinely hard problems will see the lower end of the range while routine-heavy traffic sees the higher end.

The tool also makes the savings observable rather than promissory, which is what separates Together Link from a pricing page. Every proxied session prints token and dollar totals on exit, alongside what the same session would have cost on Opus 5.5, and togetherlink usage shows the last seven days of spend. That receipt mechanism converts the claim into something a team can verify against its own traffic within a day, which is the right way to make a savings claim in a market that has heard many.

Two caveats belong next to the Together Link number, and both come from reading the product page closely. First, the baseline is Opus 5.5, the most expensive reasonable comparison; teams already routing to cheaper closed models will save less. Second, savings are per-token spend, not total cost of ownership: model quality differences mean more tokens may be spent on retries or longer contexts, and the receipt data is what reveals whether the cheaper model's output is actually good enough for the team's work.

The trust question: what a proxy actually sees

A tool that sits between a developer's agent and their code deserves the security question answered plainly, and the design choices answer most of it.

Together Link is open source, which means the translation layer, what it logs, what it forwards, what it stores, is inspectable rather than promised. It requires your own Together API key, and billing runs on that key through the same account you would use for any Together usage, so there is no shadow credential flow. Terminal agents get session-scoped settings rather than permanent rewrites, and the desktop tools get reversible profiles, which means the blast radius of any concern is one command away from zero. For a team evaluating it, the honest checklist is short: read the source, note that prompts flow to Together's servers when routed, and apply the same data-governance bar you would apply to any cloud inference provider. Nothing about Together Link weakens an existing provider review; it adds one more provider to it.

There is also a data-residency angle worth stating: routing coding traffic to open models on a hosted platform sends your code context to that platform, exactly as sending it to a closed-model API does. Teams with strict policies already handle this with provider agreements and redaction; Together Link changes which provider receives the traffic, not the governance model around it. Organisations that self-host open weights for compliance reasons are the one group the tool is not built for, and the open-weights availability of the same models is their path instead.

Who should switch, who should not

The receipt mechanism enables a decision framework that is more useful than any general recommendation, but the shape of the answer is predictable from the routing logic.

Switch candidates: teams whose agent traffic is dominated by routine work, fixes, small features, test updates, documentation, where a 0.30-dollar model performs comparably to a premium one; solo developers feeling subscription fatigue who want frontier-harness ergonomics without frontier billing; and agencies or consultancies whose coding-agent spend is a visible line item with a client on the other end. For the first group, the 80-percent end of Together's range is plausible, because the router sends exactly the traffic that overpays to the cheapest capable model.

Hold-off candidates: teams whose work is genuinely at the frontier of difficulty, deep refactors, novel algorithm implementation, large-system debugging, where the benchmark gaps between open and closed models still show up, and where one failed hour costs more than a month of premium tokens. Also hold off if your workflow depends on features the open models do not yet match, whether that is specific tool-use behaviour, context handling quirks or output formatting your pipeline assumes. The right move for these teams is not adoption but measurement: run Together Link for one week on side projects, read the receipts, compare the output quality on real work, and let the data make the argument.

The middle path deserves naming too: keep the premium subscription for the sessions that need it and route the everyday traffic through Together Link, which is exactly what the with-Anthropic-key routing mode enables. Hybrid adoption is not a compromise; it is the model the router itself implements, applied at the team level.

Why this matters for the open-model ecosystem

Together Link is distribution infrastructure for open models, and its significance goes beyond one company's billing, because it changes where the model-choice decision actually gets made: inside the tool a developer already has open, rather than in a procurement cycle nobody enjoys. The coding-agent market has been locked to closed models partly by integration quality: the harnesses were tuned for specific frontier models, and connecting them to open alternatives required per-tool configuration that most teams never attempted. By making the connection one command and reversible, Together Link lowers that barrier to near zero, which moves model competition into the only arena that matters at scale: price and quality per completed task.

The company also publishes its OpenRouter market share for the relevant models as of 30 September 2026: 40.8 percent of DeepSeek V4.1 Flash tokens, 28.2 percent of GLM 5.3 Flash tokens and 23.1 percent of Kimi K3 tokens served through its infrastructure, figures that position Together Link as the natural home for the models it routes to rather than a broker discovering them. Those figures are Together's own, but they establish the relevant credential: this is not a reseller adding open models as an afterthought, it is one of the primary serving platforms for exactly the models the tool routes to.

For builders, the strategic read matches this site's recurring argument: the frontier-closed-model subscription is becoming a lifestyle choice rather than an engineering necessity for most coding traffic, and Together Link is the first tool to make that argument operational inside the harnesses where the spending actually happens. The same discipline applies on the serving side, where the gateway landscape has shown that plumbing itself becomes attack surface, and any proxy that carries your agent traffic deserves the same scrutiny as the code it helps write. Open models now handle everyday work at a fraction of the price, the harnesses no longer care where the intelligence comes from, and tools like Together Link, along with the OpenRouter ecosystem, are the plumbing that makes the choice real. The receipts are the last mile: they turn every session into a small experiment, and a quarter of experiments is a dataset no vendor benchmark can replace. The remaining question for any team is calibration, which tasks genuinely need the frontier model, and the per-session receipts are the data that answers it.

Where the numbers stop

  • The 50-to-80-percent savings figure is Together's claim, measured against Opus 5.5 as the baseline. It is arithmetic from published per-token prices for specific routing mixes, not an audited study, and actual savings depend on each team's traffic mix and quality bar.
  • The OpenRouter market-share figures are Together's own reporting as of 30 September 2026 and have not been independently verified; OpenRouter's own dashboards are the check.
  • The router's routing quality, how often its one-per-session choice matches what the task actually needed, is not quantified anywhere in the published material. A misrouted hard session means a cheaper model attempting work above its level, and the receipts will show the cost but not the quality loss.
  • Model quality differences between open and closed models are documented on benchmarks, as this site's release coverage has reported, but benchmark performance does not guarantee satisfaction on a specific team's codebase. The reversible design exists precisely because that assessment has to be empirical.
  • The tool is in beta, per the product page, and macOS and Linux are the supported platforms at launch.

FAQ

What is Together Link?

It is a free, open-source command-line tool from Together AI that connects existing coding agents, Claude Code, Claude Desktop, Codex, ChatGPT Desktop, OpenCode and Pi, to open models on Together's serverless platform, including Kimi K3, GLM 5.3, MiniMax M3 and DeepSeek V4.1 Flash. You keep your agent's login, settings and history, install with one command, pay only for model usage at Together's per-token rates, and can switch back to your original setup with one command. Together Link's MIT license means the proxy itself is auditable, which matters because it sees your code context.

How much does Together Link actually save?

Together claims over 50 percent, and its FAQ states 50 to 80 percent compared with running every session on Opus 5.5. The range reflects routing: sessions sent to a 0.30-dollar-per-million-token model save far more than sessions sent to GLM 5.3. The claim is observable rather than promissory, because every session prints its token and dollar totals on exit alongside the Opus 5.5 equivalent, and togetherlink usage shows the last seven days of spend, so a team can verify the savings against its own traffic immediately.

How does the auto router work, and why once per session?

The router reads the first task in each session and routes quick work to a low-cost model and hard problems to a more capable one: between GLM 5.3 and GLM 5.3 Flash by default, or between Opus 5.5 and GLM 5.3 when an Anthropic API key is present. The once-per-session design is deliberate, because prompt caching requires a stable model within a session, and mid-session model switches would forfeit the cached-prefix discounts where much of the real savings live.

The short version

Together Link is a free, reversible proxy that points six mainstream coding agents at open models on Together's platform, with a once-per-session auto router that preserves prompt caching, per-session cost receipts that make the savings observable, and a claim of 50 to 80 percent lower spend against an all-Opus baseline. The tool changes nothing about how developers work, which is the point: the harness, the settings and the habits stay, and only the model behind the request changes. Its significance is bigger than one vendor's pricing: it is the plumbing that turns open models' price advantage into a one-command choice for working developers, and it makes the frontier-versus-open question answerable with each team's own receipts rather than anyone's marketing.

Sources
Subscription Form