我们如何让 Together AI 便于编程智能体使用

推出 Polymorphic Inference,首先从 Together Compiler 开始 →
推出 Together Post-Training:更好的模型、更快的运行、更低的成本 →
推出 Together Link:在你已使用的 harness 中运行开放模型 →
开源 AI 技术栈:模型、推理、路由器、harness 与工具 →
GLM-5.3 与 GLM 5.3 Flash 在 DeepSWE 上的对比 →
⚡ 按需 B200 现已在 Together GPU Clusters 上线 →
以 API 形式提供的高性能推理
面向批处理工作负载的推理
带 SLA 的基于 Token 的容量
专用模型推理
在自定义硬件上进行推理
专用容器推理
面向自定义模型的推理
在你的运行框架中运行开放模型
会随时间推移不断变好的推理
探索顶级开源模型
规模化部署的可靠 GPU 集群
前沿规模的自定义基础设施
为 AI 构建开发环境
安全存储模型权重与数据
定义你自己的 RL 与 SFT 循环
启动托管式 SFT 与 DPO 任务
微调顶级开源模型
面向生产级 AI 的系统研究
我们的全部研究论文
Together AI 技术文档
我们的最新动态与博客文章
我们的开源演示应用
实用实施指南
用开放模型构建更好的应用
在你的测试框架中运行开放模型
浏览我们的活动日程
开源 ROI 计算器
以 API 形式提供的高性能推理
面向批处理工作负载的推理
基于 Token 的容量与 SLA 保障
专用模型推理
在定制硬件上进行推理
专用容器推理
面向自定义模型的推理
在你的 harness 中运行开放模型
随时间不断变好的推理
探索顶级开源模型
大规模可靠 GPU 集群
前沿规模的自定义基础设施
为 AI 构建开发环境
安全存储模型权重与数据
定义你自己的 RL 与 SFT 循环
启动托管式 SFT 与 DPO 作业
微调顶级开源模型
面向生产级 AI 的系统研究
我们的全部研究出版物
Together AI 技术文档
我们的最新资讯与博客文章
我们的开源演示应用
实用实施指南
用开放模型构建更好的应用
在你的运行框架中运行开放模型
浏览我们的活动日历
开源 ROI 计算器
我们在 Together AI 如何做智能体评测
对我们文档、技能和 API 错误的小幅修复,把任务完成率从 67% 提升到了 96%。
今年早些时候,我们开始看到越来越多的开发者使用编码智能体来基于 Together AI 构建应用。
原因不难理解:开发者要手动把一个应用配置到可用于生产推理,可能需要几天甚至几周时间,尤其是当他们刚接触这个平台时。但对于使用我们 SDK 和 CLI 的智能体来说,这只需要几分钟——至少在理论上是这样。
实际上,我们完全不知道,那些被指向我们平台的智能体是否能与 Together 高效协作,还是说它们会遭遇障碍、陷入无谓的探索,或直接失败,并在此过程中浪费 Token。
随着开发者将越来越多工作委托给智能体,开发者体验(DX)正日益与智能体体验(AX)画上等号。你的软件对智能体来说越易用,开发者就越容易将其集成到自己的产品和工作流中。
GitHub 是出色 AX 的教科书级范例:过去一年,该平台上的活动量增至三倍,其中智能体在 2026 年发起了约 40% 的 PR(而且我们敢打赌,在所有提交中,它们编写的代码行数远超过 40%)。这要归功于 GitHub 出色的 API、CLI 和文档,它们让智能体使用起来异常容易。(本文作者甚至不知道 GitHub 有 CLI,直到智能体开始替他使用它,而现在他大概每天要用 1000+ 次)。
为了提升 Together AI 的 AX,我们需要一种方法来衡量我们的平台实际在多大程度上为智能体做好准备。在本文中,我们将介绍我们如何运行智能体评估、这些评估揭示的两个问题以及我们如何修复它们,还有我们学到了什么。
我们如何在 Together 运行智能体评估
在开始评估之前,我们需要知道智能体实际被要求做什么……这样我们才能,呃,弄清楚它们能否完成这些事。我们开始整理一份开发者在 Together 上处理的常见任务清单,比如运行批量推理任务、构建语音智能体,或管理推理端点的自动扩缩容。
所谓任务,我们其实指的就是一条提示词,也就是你告诉智能体去做某件事——例如:
列出可用的 GPU 集群区域和实例类型,打印最便宜的选项,并展示你会运行的、用于按需预留它一小时的确切命令。不要实际预留。
为了通过评估,智能体必须:
找到最新的定价信息。
调用 regions API 端点以列出可用区域。
将两者结合起来,找出最便宜的选项。
生成一条用于创建集群的有效 CLI 命令。
提示词同时要求提供可用性和定价,却没有提到这些细节位于两个不同的地方。这很现实,因为普通用户可能事先并不知道每条信息位于何处,这很容易让人类和智能体都出错。
在构建完任务列表后,我们以三种方式运行其中每一项:
基线:智能体只接收提示词,没有任何特殊配置,模拟普通开发者的工作流程。它可以使用所有默认工具,比如从网上获取文档,但我们不会给它任何特定的 MCP 连接器或技能。
MCP:智能体通过我们的 MCP 服务器直接访问我们的文档,因此当它遇到障碍时,能确切知道该去哪里搜索。
Skills:我们给智能体提供 Together 技能包,其中包含使用我们服务的说明和示例,专门为智能体编写。
每次完整评估都会用三个模型,针对每种智能体配置运行每一项任务,每项任务尝试两次——因此每种配置下每项任务共六次尝试,如下所示为我们 9 月 30 日运行的结果:
在 215 次计分运行中,智能体通过了 192 次。GPU 集群任务在所有基线运行中均失败,而在所有 Skills 运行中均通过。
当我们开始构建评估时,一切都是手工运行的:打开一个新终端,把提示词粘贴到 Claude Code 中,让智能体自行其是(或者没能做成),然后对每种配置重复一遍。这既手动又繁琐,所以一旦我们确定了想要的系统形态,就开始将其自动化。
现在我们在 Together 沙箱中运行每个智能体,这样它们就不会干扰我们的本地环境,也不会互相干扰。GitHub Actions 负责环境搭建、启动智能体、事后清理并保存结果,而一个代理负责处理智能体对 Together API 的请求并记录活动,这样我们就能看到智能体调用了哪些端点以及返回了什么。
运行结束后,一个 LLM 评审会审查任务提示词和记录的会话,然后给出三种裁定之一:
通过:任务的所有要求均已满足。
未完成:智能体尝试执行了任务,但部分必需步骤未完成或未验证。
失败:智能体过早放弃、违反了明确的约束条件,或产生了错误结果(RIP)。
失败和未完成的判定并不一定能说明问题出在智能体、API,还是证据缺失。它们只是告诉我们该从哪里开始排查。
我们也会调查通过的运行记录。智能体往往能绕开令人困惑的响应并照样完成任务,而这些恢复过程能揭示我们该修复什么,以提升 Token 效率。
为了让这种审查切实可行,我们构建了一个结果查看器,用于比较不同模型和配置的表现。对于每次运行,它会展示提示词、智能体使用的工具、收到的响应,以及任何 API 活动:
我们的结果查看器在 GPU 集群任务上比较不同配置。两种引导式配置均通过,而启用技能的运行所用工具调用次数最少、成本最低。
案例研究 1:GPU 集群定价
还记得之前那个 GPU 集群任务吗?
列出可用的 GPU 集群区域和实例类型,打印出最便宜的选项,并展示你为按需预留它一小时而会执行的确切命令。不要真的去预留。
看起来相当简单,但去年初夏我们跑评测时,Sonnet 4.6 在这个任务上 15 次尝试只通过了 4 次,即使启用了 skills 也是如此。
我们的复盘显示,失败的运行中都出现了同样的模式:Sonnet 把我们 CLI 参考文档里的示例输出(其中只列了一个区域和两种 GPU 类型)当成了实时库存。它还跳过了区域查询,在完全没有查看定价页面的情况下,直接说出它认为最便宜的选项。
问题出在我们这边。第一,示例输出没有正确标注,所以没有任何东西告诉智能体要去运行命令获取相关数据。第二,我们的 skill 文件链接的是 GPU 集群营销页面,而不是定价表,于是 Sonnet 打开了营销页面,没看到任何真实价格,就只好尽力猜测最便宜的可用 GPU。
原文较长,译文为节选;译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。
查看英文原文(How we make Together AI easy for coding agents to use)
Introducing Polymorphic Inference, starting with Together Compiler →
Introducing Together Post-Training: Better models, faster runs, lower costs →
Introducing Together Link: Run open models inside the harness you already use →
The Open Source AI Stack: models, inference, routers, harnesses & tools →
GLM-5.3 vs. GLM 5.3 Flash on DeepSWE →
⚡ On-demand B200s now available on Together GPU Clusters →
High-performance inference as APIs
Inference for batch workloads
Token-based capacity with SLAs
Dedicated Model Inference
Inference on custom hardware
Dedicated Container Inference
Inference for custom models
Run open models in your harness
Inference that gets better over time
Explore Top Open-Source Models
Reliable GPU clusters at scale
Custom infrastructure at frontier scale
Build development environments for AI
Store model weights & data securely
Define your own RL and SFT loop
Launch managed SFT and DPO jobs
Fine-tune top open-source models
Systems research for production AI
All our research publications
Technical docs for Together AI
Our latest news & blog posts
Our open-source demo apps
Practical implementation guides
Build better with open models
Run open models in your harness
Explore our events calendar
Open-source ROI calculator
High-performance inference as APIs
Inference for batch workloads
Token-based capacity with SLAs
Dedicated Model Inference
Inference on custom hardware
Dedicated Container Inference
Inference for custom models
Run open models in your harness
Inference that gets better over time
Explore Top Open-Source Models
Reliable GPU clusters at scale
Custom infrastructure at frontier scale
Build development environments for AI
Store model weights & data securely
Define your own RL and SFT loop
Launch managed SFT and DPO jobs
Fine-tune top open-source models
Systems research for production AI
All our research publications
Technical docs for Together AI
Our latest news & blog posts
Our open-source demo apps
Practical implementation guides
Build better with open models
Run open models in your harness
Explore our events calendar
Open-source ROI calculator
How we do agent evals at Together AI
Small fixes to our docs, skills, and API errors lifted task completion rate from 67% to 96%.
Earlier this year, we started seeing more and more devs using coding agents to build with Together AI.
It’s not hard to see why: It might take days or even weeks for a developer to wire up an app for production inference by hand, especially if they’re new to the platform. But for an agent using our SDK and CLI, it only takes a few minutes—at least in theory.
In practice, we had no idea whether the agents pointed at our platform were able to work with Together efficiently, or if they were hitting obstacles, going down rabbit holes or failing outright, and wasting tokens in the process.
As devs delegate more of their work to agents, developer experience (DX) is increasingly becoming synonymous with agent experience (AX). The easier your software is for agents to use, the easier it is for devs to build it into their own products and workflows.
GitHub is a textbook example of great AX: activity on the platform has tripled in the past year, with agents opening about 40% of all PRs in 2026 (and, we’re willing to bet, writing a lot more than 40% of the lines of code across all commits). This is thanks to GitHub’s phenomenal API, CLI, and docs, all of which make it exceptionally easy for agents to use. (This writer was not even aware GitHub had a CLI until agents started using it for him, and now he probably uses it 1000+ times a day).
To improve our AX at Together AI, we needed a way to measure how agent-ready our platform actually was. In this post, we’ll walk through how we run agent evals, two problems they uncovered and how we fixed them, and what we’ve learned.
How we run agent evals at Together
Before we could start evaluating, we needed to know what agents were actually being asked to do … so we could, y’know, figure out if they could do those things. We started building a list of common tasks that developers tackle on Together, like running a batch inference job, building a voice agent, or managing autoscaling for an inference endpoint.
By task, we really just mean a prompt, something you’d tell an agent to do—for example:
List the available GPU cluster regions and instance types, print the cheapest option, and show the exact command you would run to reserve it on demand for one hour. Do not actually reserve it.
To pass the eval, the agent has to:
Find the latest pricing info.
Call the regions API endpoint to list the available regions.
Combine the two to find the cheapest option.
Produce a valid CLI command for creating the cluster.
The prompt asks for both availability and pricing, without mentioning that these details live in two different places. This is realistic, as the average user probably doesn’t know up front where each piece of information lives, which could easily trip up both humans and agents.
After building our list of tasks, we run each one of them three ways:
Baseline: The agent receives just the prompt, with no special configuration, mirroring the average developer's workflow. It can use all its default tools, like fetching docs from the web, but we don't give it any specific MCP connectors or skills.
MCP: The agent gets direct access to our documentation through our MCP server, so it knows exactly where to search when it hits a roadblock.
Skills: We give the agent the Together skill package, which contains instructions and examples for using our services, written specifically for agents.
Each full evaluation runs every task against each agent configuration using three models, with two attempts at each task—so six attempts per task for each config, as shown here for our run on September 30th:
Agents passed 192 of 215 scored runs. The GPU cluster task failed every baseline run and passed every skills run.
When we started building our evals, we ran everything by hand: open a new terminal, paste a prompt into Claude Code, let the agent do its thing (or fail to do its thing), and repeat for each configuration. It was manual and tedious, so once we figured out the shape of the system we wanted, we started automating it.
Now we run each agent in a Together sandbox so they don’t interfere with our local environment or each other. GitHub Actions handles setup, starts the agent, cleans up afterward, and saves the results, while a proxy handles the agent's requests to the Together API and records the activity, so we can see which endpoints the agent calls and what comes back.
After a run finishes, an LLM judge reviews the task prompt and the recorded session, then assigns one of three verdicts:
Pass: Every task requirement was met.
Incomplete: The agent attempted the task, but some required steps were unfinished or unverified.
Fail: The agent gave up early, broke an explicit constraint, or produced an incorrect result (RIP).
Failed and incomplete verdicts don’t necessarily tell us whether the problem was with the agent, the API, or missing evidence. They just tell us where to start looking.
We investigate passing runs too. An agent can often work around confusing responses and still finish, and those recoveries show us what to fix to improve token efficiency.
To make that review practical, we built a results viewer that compares how different models and configs performed. For each run, it shows the prompt, the tools the agent used, the responses it got back, and any API activity:
Our results viewer comparing setups on the GPU cluster task. Both guided setups passed, and the skills runs used the fewest tool calls and cost the least.
Case study 1: GPU cluster pricing
Remember the GPU cluster task from earlier?
List the available GPU cluster regions and instance types, print the cheapest option, and show the exact command you would run to reserve it on demand for one hour. Do not actually reserve it.
Seems pretty simple, but when we ran our evals early last summer, Sonnet 4.6 passed only 4 of 15 attempts at this task, even with skills enabled.
Our post-mortem revealed the same pattern in the failed runs: Sonnet treated the sample output in our CLI reference, which listed a single region and two GPU types, as if it were the live inventory. It also skipped the regions lookup and named what it thought was the cheapest option without ever checking the pricing page.
The problems were on our end. First, the sample output wasn’t properly labeled, so nothing told the agent to run the command to retrieve the relevant data. Second, our skill file linked to the GPU clusters marketing page rather than the pricing table, so Sonnet opened the marketing page, didn’t see any real prices, and just made a best-effort guess at the cheapest GPU available.
More capable models were able to work around the issue. In that same period, Opus 4.8 passed 13 of 14 attempts using the same config. According to the transcript, it noticed that the list_regions response didn't include prices, so it kept searching until it found them in our docs. This is why it’s crucial to test your product with less capable models; if we had only tested with Opus, it would have taken us much longer to find the gap.
To fix it, we isolated the failure by pulling the GPU clusters skill out of the full skill package, and wrote a narrower prompt that reproduced only this issue. It failed every time when tested against the old skill file, so we had reliable repro steps (use the old skill), and an easy way to test each new version (update the skill).
We went through several iterations until we landed on a small change: two new sentences in the skill that point the agent to the pricing table, and explain how to use it with the live regions API:
Query GET > or run tg clusters list-regions --json for the live region inventory, supported instance types, and compatible CUDA/driver pairs. Open the GPU Cluster pricing table for current on-demand and reserved rates.
After this change, the task passed 100% of the time for all models we tested using the skill-enabled config.
The same GPU task also turned up a problem in our API. In a recent baseline run, Opus 5.5 got an incomplete verdict, and the transcript showed it hitting two dead ends that were not the model’s fault.
The run started well. The agent called /v1/compute/regions to retrieve the regions and instance types. Then, looking for prices, it called /v1/compute/instance-types, and the API returned a 400 with this message:
Region is required. Example: us-central-8. Use /v1/clusters/regions to get list of regions.
So the agent did what the error told it to do:
It retried the request with a region from its first lookup. Instead of instance types, it got a 404.
It called /v1/clusters/regions, the route the error suggested… but that route doesn’t exist, so it got another 404.
Our own error message had sent the agent to a route that doesn’t exist, and the retry that should have worked failed too. A developer following that message by hand would have been just as stuck. We’ve since fixed the error message to point to /v1/compute/regions, and the routing bug behind the first 404.
Case study 2: Rebuilding our skill package
We used to maintain 14 separate Together skills, one per product surface. They were a pain to use: you had to know in advance which skills applied to your workflow, then install and invoke each one. The skills also overlapped, repeating the same SDK guidance and setup instructions, and each was long enough that loading a few of them in tandem could bloat the agent’s context.
Last month, we merged those 14 skills into a single unified version. It’s still modular under the hood: to avoid context bloat, the agent first reads a short router, then opens each product guide, reference file, or sample script only when the router says it's relevant.
We hoped that one skill would beat 14, but to make sure, we ran the unified skill through our eval tasks with skills enabled. Our bar was the result from September 30, a 90% pass rate across all runs using the 14-skill config.
But the new skill was a flop—it passed just 54 of 72 runs (75%), left 18 incomplete instead of 7, and cost more than twice as much per run.
So we combed through the eval transcripts and changed the skill only where the runs pointed to a problem. Three issues kept coming up:
Too much context: The first unified router was about 14,000 characters, loaded on every task, and it told agents to read each guide in full. (So much for avoiding context bloat…) Runs ended up loading 57% more skill content than they had with the 14 separate skills. We cut the router to under 6,000 characters and ended each product guide with a menu that briefly describes what every reference and script contains, so agents open only what they need.
Stale product information: Some models used in the code examples were no longer served on serverless, and one product guide covered a deprecated feature. Agents wasted turns recovering or retrying requests that would never succeed. We moved every sample to a confirmed live model, told agents to check the catalog instead of retrying, and created a cloud agent to automatically update the skill in response to product changes.
Bugs in example code: Small problems in the scripts, such as saving JPEG bytes under a .png name, would derail every agent that used them. We fixed these at the source and added an automation to periodically live-test the code samples and keep them fresh.
With those fixes in, the unified skill passed 70 of 72 runs, 22 points better than our first attempt and 7 points better than the 14 skills we started with. Runs also took 20% less time than with the original skills on average, and the cost per run came back down to where it started.
The first unified skill dropped the pass rate to 75% and doubled cost per run. After fixes found by the evals, the final version passed 97.2% of runs at the original cost.
Where we are after four months of evals
Back in June, our docs and skills weren’t helping agents much at all. On June 15, running Opus 4.8, the baseline passed 75% of runs. Neither the docs MCP (67%) nor skills (75%) improved performance.
By September 30, across three models, the baseline had crept up to 82%. The docs MCP was at 96% and skills at 90%, with the new unified skill hitting 97% on October 8.
This isn’t a controlled comparison—the snapshots used different models and tasks, so some of these gains doubtless come from improvements to the underlying models, plus improvements we made to our CLI and SDKs. That probably explains the 7-point rise in the baseline, but the guided setups rose by 20+ points, and we credit that extra gain to the docs and skills fixes unearthed by our evals.
From June to fall, the docs MCP pass rate rose 29 points and skills 22, against 7 for the baseline. The snapshots used different tasks, models and skill versions.
Here’s the TL;DR if you’re skimming this post:
Agent-accessibility increases usage: Be like GitHub: Everything devs can do by hand with a web GUI should also be available programmatically from your CLI or SDK. We find agents work best with a CLI, because a CLI documents itself through help text. Speaking of which—
Docs are a core part of the product: Your platform may be unusable for agents if it isn’t accurately documented, or if your docs aren’t accessible (e.g. with llms.txt, a skill package, or an MCP server). CLI help text and API error message also count, and these are usually the first places an agent looks when it gets tripped up.
Guidance matters more than which frontier model you use: On September 30, all three models (Claude Sonnet, Opus, and GPT Sol) finished within a few points of each other. Adding our docs/skills bumped the pass rate up from 82% to 96% and 97% respectively.
Conversely, using only strong models can sometimes hide issues: Opus was able to work around a gap in our API and skill package, while Sonnet faceplanted into it—which is how we found and fixed the problem. When you’re running evals, make sure to test models across the capability spectrum.
Improving AX often only takes a small fix: A two-sentence addition to our skill file took our GPU cluster eval from 4 of 15 passes (for Sonnet) to 100% across all three models. The fix was small, but we might never have found it if not through the eval process.
If you’re running a dev platform, agents are using your product, or at least they’re definitely trying to. The best way to find out how well it’s going is to build your own evaluation system.
To help with that, we’re open-sourcing the package we use to build our evals. You create a list of tasks (agent prompts) and decide how to score your runs (with code tests or an LLM judge). The package launches the agents, runs the tasks, and tracks everything in a local dashboard, so you can compare configurations and past runs. It’ll be available next week, along with another blog post on how to use it.
How we do agent evals at Together AI
From Static to Polymorphic Inference: A new era for production open-source inference systems
Expanding our enterprise inference capacity with IBM Cloud and NVIDIA
Together AI announces strategic partnership with Moonshot AI to natively serve Kimi models
Announcing our $800M Series C to accelerate the shift to open-source AI
Building trust in enterprise AI: Together AI earns ISO 27001:2022 certification
From 732 bytes to nowhere: shutting down Copy Fail in production
What is an AI Native Cloud?
Together AI at NVIDIA GTC 2026: Explore our latest innovations across research and products
Introducing Together AI’s new look
Together AI welcomes Alon Gavrielov as VP of Infrastructure Strategy
Announcing Together Python SDK v2.0
Together AI and Meta partner to bring PyTorch Reinforcement Learning to the AI Native Cloud
Announcing the Together AI Startup Accelerator, purpose-built for AI Native Apps
Together AI welcomes Mahadev Konar as SVP for Infrastructure Engineering
Powering Secure AI: Together AI Achieves SOC 2 Type 2 Compliance
Together AI acquires Refuel.ai to unlock data for developers and businesses building production-grade AI applications
From AWS to Together Dedicated Endpoints: Arcee AI's journey to greater inference flexibility
Scaling AI Companions: How Dippy AI Reached Over 4 Million Tokens/Minute with Together Dedicated Endpoints
Together AI Awarded ClusterMAX™ Gold Rating by SemiAnalysis
Together AI becomes NVIDIA Cloud Partner to bolster accelerated AI offerings
Together AI Announces $305M Series B to Scale AI Acceleration Cloud for Open Source and Enterprise AI
Together AI acquires CodeSandbox to launch first-of-its-kind code interpreter for generative AI
AWS Marketplace now offering Together AI to accelerate enterprise AI development
Together AI to Co-Build Turbocharged NVIDIA GB200 Cluster with 36K Blackwell GPUs in Partnership with Hypertec Cloud
How Zomato built an AI customer support bot that doubled customer satisfaction and scaled to over 1,000 messages per minute
Introducing The Together Enterprise Platform: Run GenAI securely in any environment, with 2x faster inference and continuous model optimization
Together AI welcomes Kai Mak as CRO to accelerate gen AI adoption for AI natives and enterprises globally
Together AI and NVIDIA collaborate to power Llama 3.1 models for enterprises on NVIDIA DGX Cloud
Flash Attention received the inaugural Stanford open source software award
Together AI partners with Snowflake to bring Arctic LLM to Enterprise customers
Announcing $106M round led by Salesforce Ventures
Introducing Together AI Chief Scientist Tri Dao, as he releases FlashAttention-2 to speed up model training and inference
Together AI and Snorkel AI empower enterprises to build proprietary LLMs
Together’s $20M seed funding to build open-source AI and cloud platform
How Together and Crusoe are reducing the carbon impact of generative AI
Last year we built megakernels. This year we deleted them: The road to Together Compiler
Making open models work for long-horizon agentic workloads
How we do agent evals at Together AI
Together Compiler: Continual Compilation for AI inference
From Static to Polymorphic Inference: A new era for production open-source inference systems
Auto repair for Together GPU Clusters: from GPU fault to healthy node
Together Post-Training: frontier-grade model shaping, the way that fits you
Meta Muse Spark Open is live on Together AI
Expanding our enterprise inference capacity with IBM Cloud and NVIDIA
Together Link: frontier-quality open models in the harness you already use
How to train your own Jev for $17
Canary rollouts: upgrade models in production without downtime
原文为英文,正文由自动抓取并保留原文。
原文发布于 Together AI Blog(How we make Together AI easy for coding agents to use),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。