together-ci-integration View full skill →

Gate Together AI client, batch, fine-tuning, and deployment changes with offline contract tests plus a protected bounded live lane.

ReadGlobGrepWebFetchWriteEdit

Together AI Continuous Integration

Overview

This skill keeps ordinary pull-request gates deterministic and secretless while retaining a separately protected live lane for provider-contract drift.

Prerequisites

The repository's CI platform, test runner, and provider adapter
Sanitized fixtures for success, streaming, errors, limits, and asynchronous jobs
A protected environment and development-only Together project key for live testing
Explicit request, token, cost, concurrency, and timeout ceilings

Tool Discipline

Use Read, Glob, and Grep to inspect workflows, manifests, adapters, tests, and secret references. Use WebFetch for current SDK and API contracts. Use Write or Edit only after confirming the CI file and fork-secret boundary.

Current Contract

Pull requests run schema, adapter, fixture, retry, reconciliation, and redaction tests without a live credential.
A live lane is opt-in or trusted-branch-only, uses a development project, and sends one bounded non-sensitive request.
Fork workflows never receive TOGETHER_API_KEY or a workflow token able to retrieve it.
Paid batch, fine-tuning, and dedicated-capacity actions are plan/contract tests unless separately approved.

Authentication

Inject a development-only project key into the protected live job as TOGETHER_API_KEY. Mask it, restrict environment access, and prevent execution of untrusted code in any secret-bearing workflow.

Instructions

Inventory direct SDK calls, model constants, retry paths, async jobs, and deployment commands.
Add offline contract fixtures for response shapes, dynamic headers, terminal states, and errors.
Test model-policy fallbacks, batch ID reconciliation, key redaction, and bounded retry behavior.
Separate the live job behind a protected environment and trusted event/branch condition.
Limit live execution to a catalog/model-list probe or one small chat request with a hard budget.
Publish test evidence and cost while scrubbing prompts, responses, headers, and credentials.

Approval Boundaries

Do not expose secrets to fork code or let CI submit fine-tunes, batches, provisioned capacity, or dedicated replicas without a distinct approval boundary and teardown.

Output

Return offline coverage, fixture provenance, live-lane eligibility/result, secret boundary, request budget, cost, and any provider drift.

Error Handling

Condition	Response
No approved live key	Mark live verification skipped; keep offline gates authoritative.
Fork event requests secrets	Refuse the se…

together-common-errors View full skill →

Analyze and diagnose Together AI authentication, billing, request, model, throttling, overload, batch, fine-tuning, and endpoint failures from redacted evidence.

ReadGlobGrepWebFetchWriteEdit

Together AI Error Diagnosis

Overview

This skill classifies failures by status and workload state, preserves evidence, and avoids turning permanent errors into costly retry storms.

Prerequisites

Redacted status, response body, headers, SDK version, and request shape
The current model ID, endpoint type, and Together project alias
Batch, fine-tune, endpoint, file, or deployment IDs when applicable
The caller's timeout and retry policy

Tool Discipline

Use Read, Glob, and Grep to inspect the adapter, logs, retry code, and manifests. Use WebFetch for current error, model, and lifecycle documentation. Use Write or Edit only for the approved fix or regression test after the failure class is proven.

Current Contract

400 means request/schema trouble; 401 authentication; 402 spend limit; 404 endpoint/model; 429 throttling; 500/503 server or overload.
Context overflow can surface as 403 in Together's error table; inspect the body rather than classifying by status alone.
Model availability and redirects change. Resolve 404 against the current catalog and deprecation page.
A completed asynchronous job can still contain line-level failures; inspect its error artifact.

Authentication

Together APIs use a project-scoped Bearer key from TOGETHER_API_KEY. Verify presence and project routing without echoing the key. Treat a leaked header as a credential incident, not merely a request bug.

Instructions

Reproduce once with a sanitized minimal request and capture status, body, useful headers, latency, and SDK version.
Classify the error as credential, billing, request, model lifecycle, dynamic limit, transient provider, or asynchronous-job failure.
Compare the exact request and model to current primary documentation.
Apply the narrowest correction and add a deterministic regression case.
Retry only 429, 500, 503, or 504 with bounded jitter and an overall deadline.
Verify recovery, redact evidence, and report any provider-side incident separately.

Approval Boundaries

Do not broaden credentials, raise spend limits, switch models, or resubmit paid jobs automatically. Each changes authority, behavior, or cost and requires the relevant owner.

Output

Return the failure class, sanitized evidence, root cause, correction, retry disposition, regression coverage, and any required owner action.

Error Handling

…

Condition	Response
`401`

together-core-workflow-a View full skill →

Prepare, submit, monitor, and disposition a Together AI fine-tuning job using SDK v2, validated training data, explicit cost approval, and separate deployment verification.

ReadGlobGrepWebFetchWriteEdit

Together AI Fine-Tuning Workflow

Overview

This skill governs the expensive path from dataset qualification through an asynchronous fine-tune job and a separately approved serving handoff.

Prerequisites

A supported base model and tuning method confirmed in current Together documentation
Sanitized, licensed training and optional validation JSONL
Dataset-quality and holdout criteria
A cost ceiling, job owner, cancellation rule, and deployment decision owner

Tool Discipline

Use Read, Glob, and Grep to inspect data schemas, training configuration, and existing evaluations. Use WebFetch for current supported models and job parameters. Use Write or Edit only for approved data-validation, job-manifest, or evaluation files; never copy raw sensitive data into the skill output.

Current Contract

Use Together Python SDK v2 and client.files.upload() plus client.fine_tuning.create().
The CLI accepts a file ID or local path and reports an estimated price before confirmation.
Prefer LoRA unless full tuning is justified; choose SFT or DPO from the behavior objective.
A completed training job does not automatically deploy a model. Serving is a separate endpoint decision.

Authentication

Fine-tuning APIs use the project-scoped TOGETHER_API_KEY Bearer credential. A W&B key, private Hugging Face token, or dataset-store credential is separate and must be scoped, stored, and redacted independently.

Instructions

Define the target behavior, baseline evaluation, tuning method, and success threshold.
Validate format, licenses, consent, duplication, leakage, train/validation separation, and token distribution.
Confirm the base model is currently tunable and estimate cost before upload.
Upload with the fine-tune purpose and persist the returned file ID in a redacted manifest.
Submit only after approval; persist job ID, parameters, dataset hash, owner, and cancellation threshold.
Poll boundedly, review events/checkpoints, evaluate the output, and hand deployment off separately.

Approval Boundaries

Do not upload data or confirm a paid job without dataset authority and cost approval. Do not deploy the resulting model or delete training artifacts automatically.

Output

Return dataset checks, base model, method, estimated/approved cost, file and job references, terminal state, evaluation delta, and deployment recommendation.

Error Handling

Condition	Response
Dataset validation fails	Stop before upload and report line-level categories without sensitive rows.
Base mo…

together-core-workflow-b View full skill →

Run Together AI asynchronous batch inference from validated JSONL through upload, job polling, output/error download, and custom-id reconciliation.

ReadGlobGrepWebFetchWriteEdit

Together AI Batch Inference

Overview

This skill converts independent offline requests into a recoverable Batch API job and reconciles every success and failure without relying on output order.

Prerequisites

Independent request records suitable for asynchronous processing
A currently batch-eligible model and supported endpoint
Stable unique custom_id values and an approved output location
A request/token budget, retention policy, and job owner

Tool Discipline

Use Read, Glob, and Grep to inspect input generation, schemas, and reconciliation code. Use WebFetch for current batch eligibility and SDK response shapes. Use Write or Edit only for approved JSONL, manifests, or reconciliation logic; avoid placing sensitive prompts in diagnostic output.

Current Contract

Each JSONL line contains a unique custom_id and a request body.
Upload with purpose="batch-api"; create with client.batches.create() and the target endpoint.
Results can arrive in arbitrary order. Join by custom_id.
A COMPLETED batch can still have per-request failures in error_file_id; inspect both files.

Authentication

File and batch APIs use the project-scoped TOGETHER_API_KEY as a Bearer credential. Keep remote file IDs and batch IDs as operational references, but redact the credential and sensitive request bodies.

Instructions

Confirm requests are independent and the chosen model is currently batch eligible.
Validate JSONL syntax, endpoint body schema, unique IDs, request count, and token bounds locally.
Upload the file with batch purpose and record its hash and returned file ID.
Create the job with the uploaded ID and exact API endpoint; persist the returned batch ID.
Poll status with bounded backoff until terminal, without assuming the usual completion time.
Download output and error files, reconcile all IDs, verify counts, and apply retention cleanup.

Approval Boundaries

Do not upload regulated or customer data without approval. Do not resubmit an ambiguous job: first reconcile the prior batch ID to avoid duplicate spend.

Output

Return input hash/count, endpoint, model, file and batch references, terminal state, success/error counts, reconciliation result, cost evidence, and cleanup disposition.

Error Handling

Condition	Response
JSONL validation fails	Stop before upload and report offending line numbers.
Model is not batch eligible	Choose another model explicitly or use synch…

together-cost-tuning View full skill →

Reduce Together AI spend using measured token usage, live per-model prices, cached-input evidence, batch discounts, model evaluation, and dedicated break-even analysis.

ReadGlobGrepWebFetchWriteEdit

Together AI Cost Tuning

Overview

This skill builds a reproducible cost model from actual usage and current pricing rather than embedding a price table that will drift.

Prerequisites

A representative usage window with input, cached-input, output, and request counts
Current model catalog/pricing and billing analytics access
Quality, latency, context, and availability requirements
A monthly budget and an owner for model or capacity changes

Tool Discipline

Use Read, Glob, and Grep to find model selection, token bounds, caching, batch, and telemetry logic. Use WebFetch only for current official pricing and eligibility. Use Write or Edit for an approved cost model, instrumentation, or configuration change.

Current Contract

Serverless models bill from current per-model input/output rates; some expose discounted cached input.
Eligible batch work can cost up to 50% less, but eligibility and discount vary by model.
Dedicated Model Inference bills per minute per running replica and hardware, not per token.
Usage and prices change; snapshot retrieval time and source with every forecast.

Authentication

Billing and usage views require authorized Together project access. API workloads use TOGETHER_API_KEY; record aggregate usage and project alias only, not the credential or sensitive request content.

Instructions

Group measured requests by model, workload, token class, latency, and success state.
Fetch current pricing and batch eligibility, recording retrieval time and source.
Reconcile calculated cost with Together billing analytics before proposing savings.
Evaluate output bounds, prompt reuse/caching, smaller models, and asynchronous batch in that order.
Benchmark quality and latency before shifting models or endpoint type.
Compare steady utilization with dedicated per-minute capacity, then publish forecast, risk, rollback, and owner.

Approval Boundaries

Do not change a production model, reduce quality/safety controls, submit batch jobs, or provision dedicated replicas solely from a spreadsheet estimate.

Output

Return source-stamped prices, usage baseline, reconciled cost, option-by-option savings, quality/latency evidence, break-even assumptions, recommendation, and rollback.

Error Handling

Condition	Response
Usage lacks token fields	Add measurement before estimating savings.
Catalog and invoice diverge	Use billed data for history and current catalog for forward scenarios.
Batch model ineligible	Price synchronous or another explici…

together-deploy-integration View full skill →

Deploy and roll back Together AI integrations across serverless inference or v2 Dedicated Model Inference with secret injection, health probes, traffic control, and cost shutdown.

ReadGlobGrepWebFetchWriteEdit

Together AI Deployment Integration

Overview

This skill separates application release from paid Together capacity changes and defines a reversible deployment for serverless or current v2 dedicated inference.

Prerequisites

A tested application artifact and model-quality evidence
Environment-scoped secret references and network egress policy
Current model availability plus serverless or dedicated capacity decision
Health, canary, rollback, cost, and teardown owners

Tool Discipline

Use Read, Glob, and Grep to inspect manifests, secret wiring, health checks, and rollback automation. Use WebFetch for current Together model and DMI lifecycle contracts. Use Write or Edit only for approved deployment files after the target platform is confirmed.

Current Contract

Serverless needs no GPU provisioning and uses the shared inference API with a current model ID.
New dedicated deployments use Together's v2 endpoint/deployment model and beta management surfaces.
Legacy v1 endpoint creation is retired; do not publish client.endpoints.create(model=..., hardware=...) as the new path.
Dedicated replicas bill while running. Scale to zero or delete after an approved rollback or experiment.

Authentication

Inject a project-scoped TOGETHER_API_KEY from the deployment platform's secret manager. Dedicated management also requires authorized project context; never expose management identifiers or Bearer headers unnecessarily.

Instructions

Classify the workload as serverless or dedicated from latency, throughput, model, and utilization evidence.
Pin the application artifact, SDK major, configuration schema, model policy, and secret references.
For dedicated v2, resolve model/config resources, create the deployment, and poll to ready before routing traffic.
Run a non-sensitive health probe that validates provider reachability and response shape.
Shift a bounded canary while monitoring error rate, latency, usage, quality, and cost.
Promote or roll back explicitly; scale obsolete dedicated replicas to zero and verify billing disposition.

Approval Boundaries

Do not provision paid hardware, change traffic weights, rotate production keys, or promote a model without the named owners and an executable rollback.

Output

Return deployment mode, artifact/model/config identities, secret reference, readiness and canary evidence, traffic state, cost state, rollback result, and teardown owner.

Error Handling

Condition	Response
Legacy v1 create returns `403`	Stop and migrate to the current v2…

together-hello-world View full skill →

Build a bounded Together AI chat-completion probe with a current model selected from the live catalog, optional streaming, usage capture, and redacted evidence.

ReadGlobGrepWebFetchWriteEdit

Together AI First Inference

Overview

This skill produces the smallest observable chat-completion probe without freezing a model catalog entry into application policy.

Prerequisites

A configured TOGETHER_API_KEY secret reference
Together Python SDK v2, current TypeScript SDK, or an HTTPS client
A current chat model resolved from the Together catalog
A small approved prompt containing no sensitive data

Tool Discipline

Use Read, Glob, and Grep to inspect the client wrapper and configuration. Use WebFetch for the current quickstart, model catalog, and response contract. Use Write or Edit only for the approved sample or test file; never place the key in code.

Current Contract

Call client.chat.completions.create() with a Together model ID such as the current quickstart example.
For streaming, iterate chunks and guard for an empty choices array before reading delta.content.
Capture finish_reason and usage; bound max_tokens, timeout, and retry count.
Re-resolve the model from the live catalog before production use because availability and redirects change.

Authentication

The SDK reads TOGETHER_API_KEY. Direct REST requests send the same project key as a Bearer token to https://api.together.ai/v1/chat/completions. Never return or log the header.

Instructions

Confirm the requested modality is chat and select a current chat-capable model.
Create one system message and one sanitized user message with an explicit output bound.
Choose non-streaming for contract inspection or streaming for latency and chunk handling.
Validate status, non-empty content, finish reason, model identifier, and usage fields.
Record latency and request outcome without storing the prompt or response when either is sensitive.
Remove disposable output and hand off the model-selection rationale.

Approval Boundaries

Do not send customer data, regulated content, or proprietary prompts until data handling and retention are approved. Do not silently switch to a more expensive or materially different model.

Output

Return the client/runtime, resolved model, streaming mode, bounded request parameters, status, finish reason, token usage, latency, and redaction disposition.

Error Handling

Condition	Response
`401`	Stop and repair credential injection.
`404`	Refresh the model catalog and deprecation page.
`429`	Read dynamic limit headers a…

together-install-auth View full skill →

Install Together AI SDK v2 and configure a project-scoped API key with least-privilege storage and a read-only model-list verification.

ReadGlobGrepWebFetchWriteEdit

Together AI Installation and Authentication

Overview

This skill selects the current Together client, keeps credentials outside source control, and proves access with a non-generating model-list request.

Prerequisites

A Together AI project and an administrator-approved key owner
Python 3.10+ for together>=2.0.0, Node.js for the TypeScript SDK, or an HTTPS client
An approved secret manager for deployed environments
The repository and runtime that will consume the credential

Tool Discipline

Use Read, Glob, and Grep to inspect dependency manifests, environment-variable names, and existing client wrappers. Use WebFetch only for current Together documentation. Use Write or Edit only after confirming the target files; never write a real key or .env value.

Current Contract

New Python integrations target the v2 SDK: together>=2.0.0.
SDK clients read TOGETHER_API_KEY by default; REST uses Authorization: Bearer <token>.
API keys are scoped to a Together project. Separate development, CI, and production keys.
Verify with client.models.list() or GET /v1/models; do not spend inference tokens for an auth probe.

Authentication

Create the key in the intended Together project, copy it once into the approved secret store, and inject it at runtime as TOGETHER_API_KEY. Redact the value, authorization header, and secret-manager path from logs and examples. Rotation means creating a replacement, deploying it, verifying, and revoking the old key.

Instructions

Inventory the language, package manager, existing OpenAI-compatible client, and deployment environments.
Pin the current major SDK and record the resolved version in the lockfile.
Define TOGETHER_API_KEY in local documentation and deployment configuration without adding a value to the repository.
Initialize the native Together client, or configure an OpenAI client with https://api.together.ai/v1.
Run or hand off one read-only model-list probe and record only status, project alias, SDK version, and model count.
Document key ownership, rotation, revocation, and environment separation.

Approval Boundaries

Do not create, reveal, broaden, rotate, or revoke a production key without the owning project administrator. Do not add a credential to tracked files, command history, test fixtures, or CI available to untrusted forks.

Output

Return the selected client, pinned version, environment-variable contract, secret reference, read-only verification result, and rotation owner.

Error Handling

…

together-local-dev-loop View full skill →

Develop Together AI integrations with a fake transport, recorded response shapes, deterministic assertions, and an opt-in bounded live probe.

ReadGlobGrepWebFetchWriteEdit

Together AI Local Development Loop

Overview

This skill keeps ordinary development offline and deterministic while retaining one explicit live lane for detecting provider-contract drift.

Prerequisites

The repository's test runner and client abstraction
Sanitized fixtures for success, streaming chunks, 401, 404, 429, and 503
A separate development project key for an opt-in live probe
A fixed token and request budget for that probe

Tool Discipline

Use Read, Glob, and Grep to discover the wrapper, tests, fixtures, and environment gates. Use WebFetch to confirm current response and error shapes. Use Write or Edit only after matching repository conventions; never save live prompts, outputs, or credentials as fixtures.

Current Contract

Inject a client or transport rather than mocking SDK internals throughout the codebase.
Preserve the SDK response fields the application actually consumes: choices, deltas, finish reason, usage, and error status.
Make live tests opt-in, bounded, non-sensitive, and visibly skipped when no approved key exists.
Test dynamic limit-header handling without hard-coding permanent RPM or TPM values.

Authentication

Offline tests use no key. The live lane reads a development-only TOGETHER_API_KEY from the approved test secret store and must be unavailable to untrusted fork workflows.

Instructions

Locate the narrowest Together client boundary and enumerate consumed fields.
Build typed fake responses for non-streaming, streaming, and each retry class.
Assert model selection, request bounds, idempotent reconciliation keys, and redaction.
Gate the live probe behind an explicit environment switch plus a development key.
Limit the live probe to one small request against a catalog-resolved model.
Compare shape-level behavior, update sanitized fixtures if approved, and record cost/cleanup.

Approval Boundaries

Do not expose a live key to pull requests from forks. Do not refresh fixtures from customer traffic or authorize an unbounded live test suite.

Output

Return fake-contract coverage, offline test results, live-lane disposition, model-resolution evidence, request budget, and any detected SDK or API drift.

Error Handling

Condition	Response
SDK object is hard to fake	Introduce an application-owned adapter; do not patch deep internals.
Live key absent	Mark the live lane skipped, not passed.
Fixture contains sensitive text	Remove it and replace it with synthetic…

together-prod-checklist View full skill →

Review a Together AI production release across model policy, auth, data controls, dynamic limits, retries, observability, cost, deprecations, asynchronous recovery, and rollback.

ReadGlobGrepWebFetchWriteEdit

Together AI Production Checklist

Overview

This skill produces a release decision backed by current provider, application, security, reliability, quality, and cost evidence.

Prerequisites

A pinned release artifact and environment configuration
Model/endpoint quality, latency, availability, and cost thresholds
Secret, data handling, monitoring, incident, and rollback owners
Current Together model, limit, pricing, and deprecation evidence

Tool Discipline

Use Read, Glob, and Grep to inspect configuration, model policy, retry logic, tests, and runbooks. Use WebFetch for current Together contracts. Use Write or Edit only for approved remediation or the release record.

Current Contract

Resolve model IDs and deprecation status at review time; do not trust an old README.
Read dynamic limit headers and bound concurrency, tokens, retries, and queues.
Separate serverless, batch, fine-tuning, and dedicated failure/recovery paths.
Dedicated replicas require explicit cost shutdown; batches require output/error reconciliation.

Authentication

Verify environment-specific project keys, secret-manager injection, rotation/revocation, fork isolation, and log redaction. Never prove readiness by displaying a credential or authorization header.

Instructions

Pin artifact, SDK major, configuration, model policy, and environment identity.
Verify authentication, data classification, redaction, retention, and tenant isolation.
Run offline tests and a bounded live canary for response shape, latency, quality, usage, and limits.
Exercise 401, 402, 404, 429, 503, timeout, partial batch, and model-deprecation paths.
Reconcile spend forecasts with billing analytics and confirm alerts and dedicated teardown.
Execute rollback/degradation evidence, assign all exceptions, and issue go, conditional-go, or no-go.

Approval Boundaries

Do not waive a failed security, quality, cost, or recovery control. Conditional approval must name the owner, deadline, monitoring, and rollback trigger.

Output

Return a control-by-control evidence matrix, exceptions, owners, current-provider snapshot, rollback result, cost state, and release verdict.

Error Handling

…

Condition	Response
Model is deprecated or redirected	Re-evaluate behavior and migrate before go-live.
Live probe cannot run	Do not report it passed; issue an explicit exception or no-go.
Cost/usage is unreconciled	Block capacity changes and assign the billing owner.

together-rate-limits View full skill →

Analyze and control Together AI serverless concurrency from dynamic per-model request/token headers, bounded queues, jittered retries, and batch or dedicated alternatives.

ReadGlobGrepWebFetchWriteEdit

Together AI Dynamic Rate Limits

Overview

This skill replaces fixed quota tables with adaptive control driven by Together's current response headers and observed workload demand.

Prerequisites

The exact model IDs and traffic profile by request and token volume
Access to response headers from the HTTP or SDK transport
Queue-latency, retry, spend, and failure budgets
A decision owner for batch, provisioned, or dedicated capacity

Tool Discipline

Use Read, Glob, and Grep to locate concurrency, queue, retry, and telemetry code. Use WebFetch for the current dynamic-limit header contract. Use Write or Edit only after the target limiter and tests are identified.

Current Contract

Serverless limits are dynamic per organization and model; historical account tiers are retired.
Read request and token limit/remaining/reset headers on every response and maintain state per model.
Treat displayed RPM as a per-second enforcement budget when Together documents that conversion.
Use batch for delay-tolerant bursts and dedicated capacity for predictable reserved throughput.

Authentication

Limit headers arrive on authenticated serverless inference responses using the project-scoped Bearer key. Record numeric headers and model alias only; never retain the credential or sensitive body.

Instructions

Inventory callers, models, concurrency, token sizes, queue depth, and existing retries.
Capture the current x-ratelimit-* and x-tokenlimit-* fields from redacted responses.
Build independent request and token budgets keyed by model and organization context.
Admit work through a bounded queue; reserve headroom for retries and interactive traffic.
On 429, honor reset evidence, apply jitter, and stop at the request deadline.
Load-test below approval bounds, then choose serverless, batch, or dedicated capacity from measured demand.

Approval Boundaries

Do not manufacture fixed limits, increase retry concurrency after throttling, or move to paid reserved hardware without explicit cost and capacity approval.

Output

Return observed headers, per-model limiter settings, queue/retry budgets, load-test evidence, dropped/deferred work, and capacity recommendation.

Error Handling

…

Condition	Response
Limit headers missing	Fall back conservatively and surface transport visibility as a blocker.
`429` persists	Reduce concurrency; do not multiply retries.
Queue deadline exceeded	Fail or defer according to workload policy.

together-reference-architecture View full skill →

Design a production Together AI service with a typed provider boundary, policy-based model routing, serverless and dedicated lanes, batch workers, telemetry, budgets, and reversible degradation.

ReadGlobGrepWebFetchWriteEdit

Together AI Reference Architecture

Overview

This skill turns workload requirements into explicit real-time, batch, and dedicated paths with one governed provider boundary and observable cost/quality behavior.

Prerequisites

Workload classes, modalities, volumes, latency objectives, and data classifications
Model-quality evaluations and fallback constraints
Availability, cost, retention, residency, and recovery objectives
Existing gateway, queue, telemetry, and secret-management topology

Tool Discipline

Use Read, Glob, and Grep to map callers, trust boundaries, queues, storage, and observability. Use WebFetch for current Together capabilities and limits. Use Write or Edit only for approved diagrams, ADRs, interfaces, or configuration.

Current Contract

Interactive serverless and dedicated models share inference request shapes, but capacity and billing differ.
Batch is an asynchronous file/job path with arbitrary result order and separate error artifacts.
Model IDs, prices, redirects, and availability are runtime policy inputs, not constants scattered through callers.
Credentials are project-scoped; isolate environments and inject keys at the gateway or worker boundary.

Authentication

Use separate TOGETHER_API_KEY references per environment and workload authority. Keep provider credentials server-side. Internal callers authenticate to the application gateway independently; they never receive the Together key.

Instructions

Partition workloads into interactive, offline batch, training, and reserved-capacity classes.
Define a typed provider adapter and policy service for model, bounds, fallback, and deprecation state.
Place bounded queues around bursty and asynchronous work with durable IDs and reconciliation.
Add per-model request/token control, circuit breaking, usage/cost telemetry, and quality sampling.
Define data redaction, retention, tenant isolation, and secret rotation at each trust boundary.
Document degradation, model migration, batch recovery, dedicated scale-to-zero, and provider-exit paths.

Approval Boundaries

Do not introduce provider failover, cross-region data movement, dedicated capacity, or automatic model substitution without security, quality, reliability, and cost owners.

Output

Return component/flow topology, trust boundaries, provider interfaces, model policy, capacity lanes, observability, budgets, failure modes, rollback, and decision owners.

Error Handling

…

Condition	Response
Requirements conflict	Record the tradeoff and seek the named decision owner.

together-sdk-patterns View full skill →

Encapsulate Together AI SDK v2 behind a typed adapter with catalog-resolved models, bounded retries, streaming normalization, usage capture, and OpenAI-compatible migration seams.

ReadGlobGrepWebFetchWriteEdit

Together AI SDK Patterns

Overview

This skill creates an application-owned boundary around Together's native v2 client or OpenAI-compatible surface so provider changes do not leak through every caller.

Prerequisites

The repository's language, dependency manager, and existing client abstractions
Required capabilities such as chat, streaming, embeddings, batch, or fine-tuning
Latency, retry, token, and spend budgets
A policy for model selection and deprecation response

Tool Discipline

Use Read, Glob, and Grep to map existing provider calls and error handling. Use WebFetch for current SDK and API contracts. Use Write or Edit only to implement the approved adapter and focused tests.

Current Contract

Prefer the Together Python v2 client for Together-native features; v1 is maintenance-only.
OpenAI clients require both the Together project key and base_url="https://api.together.ai/v1".
Together model IDs use provider/model names; OpenAI-native model strings return 404.
Normalize streaming chunks defensively and capture both ordinary usage and nested reasoning/cached-token fields when present.

Authentication

Construct clients from runtime-injected TOGETHER_API_KEY. Keep the key out of adapter configuration objects that may be logged or serialized. REST and OpenAI-compatible clients send it as a Bearer token.

Instructions

Inventory direct Together and OpenAI-compatible calls, consumed fields, and retry behavior.
Define typed request/result/error interfaces owned by the application.
Centralize base URL, timeouts, model policy, request bounds, and credential injection.
Normalize full and streaming responses without discarding finish reason, usage, warnings, or request metadata.
Retry only bounded transient classes with jitter; surface auth, billing, validation, and model errors immediately.
Add fake-transport contract tests and one opt-in live compatibility probe.

Approval Boundaries

Do not change the default model, retry amplification, or OpenAI-to-Together routing globally without latency, quality, and cost evidence plus a rollback.

Output

Return the adapter interface, runtime configuration contract, normalized result/error shapes, retry policy, model policy, and test evidence.

Error Handling

Condition	Response
OpenAI model ID returns `404`	Resolve a Together model ID; do not rewrite the error as transient.
Stream chunk has no choices	Skip safely and continue until terminal evidence.
S…

together-security-basics View full skill →

Secure Together AI integrations with project-scoped keys, environment isolation, prompt/output data controls, bounded model behavior, safe logging, rotation, and incident response.

ReadGlobGrepWebFetchWriteEdit

Together AI Security Basics

Overview

This skill maps credentials, data, model output, tool use, logs, and paid asynchronous actions to explicit controls and owners.

Prerequisites

Data classification and approved Together use cases
Project/environment inventory and credential owners
Request/response logging, retention, and deletion policy
Model-output validation and any downstream tool-execution boundary

Tool Discipline

Use Read, Glob, and Grep to find provider calls, secrets, logging, persistence, and model-output consumers. Use WebFetch for current Together authentication and API behavior. Use Write or Edit only for approved controls; never read or reproduce secret values.

Current Contract

Together keys are project-scoped; create separate development, CI, and production credentials.
Keep keys server-side and out of source, browser bundles, prompts, logs, fixtures, and fork workflows.
Treat prompts, uploaded files, outputs, model IDs, and job artifacts according to their data classification.
Model output is untrusted input to downstream systems; validate structure and require authorization for side effects.

Authentication

Inject TOGETHER_API_KEY from an approved secret store and send it only as the SDK credential or Bearer header over HTTPS. Define rotation, revocation, leak detection, owner removal, and emergency shutdown procedures.

Instructions

Inventory keys, projects, callers, endpoints, data classes, storage, and downstream actions.
Remove tracked or client-side credentials and separate secrets by environment and workload.
Minimize prompt/upload content, redact diagnostics, and enforce retention/deletion policy.
Validate structured output and isolate any tool execution behind independent authorization.
Bound tokens, concurrency, retries, batch/fine-tune submissions, and dedicated provisioning.
Test credential revocation, provider failure, prompt injection, unsafe output, and incident response.

Approval Boundaries

Do not upload sensitive datasets, enable model-driven side effects, broaden key sharing, or retain prompts/outputs beyond policy without the named data and security authorities.

Output

Return trust boundaries, key/project map, data-flow controls, output-validation rules, cost/side-effect bounds, test evidence, gaps, owners, and remediation deadlines.

Error Handling

…

Condition	Response
Credential is exposed	Revoke or rotate immediately and scrub retained artifacts.
Data classification unknown	Stop before sending or uploading content.

together-upgrade-migration View full skill →

Migrate Together AI Python SDK v1, OpenAI-compatible clients, deprecated models, or legacy dedicated endpoints with inventory, contract tests, canaries, and rollback.

ReadGlobGrepWebFetchWriteEdit

Together AI Upgrade and Migration

Overview

This skill moves one Together contract at a time while preserving response, model-quality, cost, and rollback evidence.

Prerequisites

An inventory of SDK versions, API calls, model IDs, and dedicated resources
Current migration, model lifecycle, and deprecation documentation
Golden requests/evaluations plus latency and cost baselines
A rollback target and owners for traffic, data, billing, and teardown

Tool Discipline

Use Read, Glob, and Grep to locate dependencies, direct calls, model constants, response assumptions, and endpoint management. Use WebFetch for current migration and deprecation contracts. Use Write or Edit only after scope and rollback are agreed.

Current Contract

Python v1 is maintenance-only; new features target together>=2.0.0 and may use changed method/response shapes.
OpenAI-compatible migration requires Together's base URL, project key, and Together model IDs.
Same-lineage model upgrades may redirect after notice; materially new models require explicit migration and evaluation.
New dedicated capacity uses v2 DMI; legacy v1 create/restart paths are retired.

Authentication

Preserve project-scoped TOGETHER_API_KEY injection while changing clients or endpoints. Never reuse development keys in production or expose a key during dual-run comparison.

Instructions

Classify the migration as SDK, model, compatibility layer, or dedicated endpoint and freeze the baseline.
Inventory every call, parameter, response field, model, job, retry, and management resource in scope.
Build contract and golden-quality tests before changing dependencies or routing.
Implement the target behind a reversible configuration or traffic boundary.
Canary with sanitized requests; compare behavior, latency, usage, errors, limits, and cost.
Promote explicitly, monitor, remove obsolete resources only after retention/rollback approval, and update the runbook.

Approval Boundaries

Do not accept silent model substitution, delete legacy endpoints, revoke keys, or shift production traffic without evaluated behavior and an executable rollback.

Output

Return source/target contracts, inventory, test delta, canary metrics, model/deprecation evidence, traffic state, rollback proof, obsolete-resource disposition, and owners.

Error Handling

…

Condition	Response
SDK response shape changes	Adapt at the provider boundary and keep caller contracts stable.
Model quality regresses	Roll back routing and revisit the candidate.

together-webhooks-events View full skill →

Convert Together AI batch, fine-tuning, upload, and dedicated-deployment job states into idempotent internal events using bounded polling and an optional owned callback.

ReadGlobGrepWebFetchWriteEdit

Together AI Job Events

Overview

Together documents asynchronous retrieval and polling for batch, fine-tune, upload, and deployment state. This skill emits internal events from that source of truth instead of inventing a provider-signed webhook.

Prerequisites

The job type, ID, project, terminal states, and retrieval method
A durable cursor/state store and idempotency key policy
Poll interval, deadline, retry budget, and event retention policy
An owned callback endpoint only if downstream push delivery is required

Tool Discipline

Use Read, Glob, and Grep to inspect job persistence, pollers, queues, and callback handlers. Use WebFetch to confirm current job states and retrieval methods. Use Write or Edit only after the event contract and storage boundary are approved.

Current Contract

Do not expect a universal Together webhook signature header; no general signed webhook surface is documented for these job APIs.
Persist the provider job ID before polling and derive internal idempotency from job ID plus observed state/version.
Treat terminal job status and per-item output/error artifacts as separate facts.
Deliver downstream callbacks from infrastructure you own and authenticate them with your own signing scheme.

Authentication

Poll Together with the project-scoped TOGETHER_API_KEY Bearer credential. For an owned callback, use a separate secret, timestamped signature, replay window, and rotation plan; never present that signature as Together-generated.

Instructions

Map provider job states to a small versioned internal event schema.
Persist job ID, last observed state, next poll time, attempt count, and deadline.
Retrieve with bounded exponential backoff and jitter; stop at terminal state or deadline.
Emit only on meaningful transitions and deduplicate by job/state key.
On completion, fetch output and error artifacts before declaring record-level success.
If needed, sign and deliver an internal callback with replay protection and a dead-letter path.

Approval Boundaries

Do not expose the Together key to callback consumers, invent provider signatures, or delete remote/local job artifacts before reconciliation and retention approval.

Output

Return the provider job reference, state mapping, poll schedule, transition ledger, reconciliation status, callback delivery evidence, and deadline/dead-letter disposition.

Error Handling

Condition	Response
Retrieval is transiently unavailable	Retry with jitter inside the overall deadline.
Job ID is missing	Stop; do not c…

together-pack

Installation

What It Does

Skills (16) plugin-local skills

Together AI Continuous Integration

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Error Diagnosis

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Fine-Tuning Workflow

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Batch Inference

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Cost Tuning

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Deployment Integration

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI First Inference

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication

Instructions

Approval Boundaries

Output

Error Handling

Together AI Installation and Authentication

Overview

Prerequisites

Tool Discipline

Current Contract

Authentication