agentleFS
0xatd0xatd/cheaptokens-skills/skills/venice-models/SKILL.md

venice-models

Skill2 starsChanged 5 months agoMITView on GitHub

Discover Venice models, their capabilities, constraints, and pricing. Covers GET /models (with ?type filter), /models/traits, /models/compatibility_mapping, the ModelResponse schema (capabilities, constraints, pricing per type), and how to use this to pick the right model programmatically.

1 other project uses a version of this, 1 of them edited.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 1 is distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    All three take an optional ?type= filter: text, image, video, music, tts, asr, embedding, upscale, inpaint, all, code.

    line 16
  2. Very specific:

    All three are authenticated (Bearer API key or x402 SIWE) like every other /api/v1 route.

    line 18
  3. Distinctive:

    Use this to avoid hard-coding model IDs — resolve a trait at boot and cache for the session.

    line 122

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Venice Models

Three read-only endpoints for model discovery — all GET:

EndpointReturns
/modelsFull model catalog with model_spec (capabilities, constraints, pricing).
/models/traitsTrait → model ID mapping (e.g. "default", "fastest", "default_reasoning", "highest_quality").
/models/compatibility_mappingLegacy / OpenAI / third-party model ID → Venice model ID aliases.

All three take an optional ?type= filter: text, image, video, music, tts, asr, embedding, upscale, inpaint, all, code.

All three are authenticated (Bearer API key or x402 SIWE) like every other /api/v1 route.

Use when

  • You need to pick a model at runtime based on capabilities (vision, reasoning, function calling, E2EE, X search, multi-image, …).
  • You need to validate a request against a model's constraints (prompt length, aspect ratio, resolution, steps).
  • You need the current price per million tokens / per image / per second / per 1k chars to build a cost estimate.
  • You want to resolve a user-friendly trait name (e.g. default, default_reasoning, highest_quality) or a frontier-style ID (openai-gpt-54-pro, claude-opus-4-7) to a concrete Venice model ID.

GET /models

curl "https://api.venice.ai/api/v1/models?type=text"
{
  "object": "list",
  "type": "text",
  "data": [
    {
      "id": "zai-org-glm-5-1",
      "created": 1699000000,
      "model_spec": {
        "name": "GLM 5.1",
        "description": "Balanced blend of speed and capability...",
        "availableContextTokens": 200000,
        "maxCompletionTokens": 24000,
        "privacy": "private",
        "beta": false,
        "betaModel": false,
        "modelSource": "https://huggingface.co/zai-org/GLM-5.1",
        "offline": false,
        "capabilities": { ... },
        "constraints": { ... },
        "pricing": { ... },
        "regionRestrictions": ["US"],
        "deprecation": {"date": "2025-03-01T00:00:00.000Z"}
      }
    }
  ]
}

model_spec.capabilities — text models

FlagMeaning
optimizedForCodeTuned for coding tasks.
quantizationfp4 / fp8 / fp16 / bf16 / int8 / int4 / not-available.
supportsFunctionCallingTools are allowed.
supportsReasoningEmits <thinking>...</thinking> blocks (and/or provider-specific reasoning_content).
supportsReasoningEffortHonors reasoning.effort / reasoning_effort.
supportsResponseSchemaHonors response_format: json_schema.
supportsMultipleImages + maxImagesMulti-image vision support.
supportsVisionAccepts image_url parts.
supportsVideoInputAccepts video_url parts.
supportsWebSearchHonors venice_parameters.enable_web_search.
supportsLogProbsHonors logprobs / top_logprobs.
supportsTeeAttestationRuns inside a TEE with hardware attestation.
supportsE2EEEnd-to-end encrypted inference available (requires TEE).
supportsXSearchxAI native web + X/Twitter search.
supportsAudioInputAccepts audio-content message parts (set by the runtime capability builder — not part of the OpenAPI strict schema but appears on /models responses).

model_spec.constraints — by model family

  • Text — temperature.default, top_p.default, and {frequency,presence,repetition}_penalty.default.
  • Image — promptCharacterLimit, widthHeightDivisor, steps.{default,max}, optional aspectRatios[] + defaultAspectRatio, optional resolutions[] + defaultResolution (the last two appear only on models that use ratio/resolution-based sizing).
  • Video — aspect_ratios[], resolutions[], durations[], model_type (text-to-video/image-to-video/video), audio, audio_configurable, prompt_character_limit.
  • Inpaint / edit — aspectRatios[], promptCharacterLimit, combineImages.
  • TTS / Music (fields surface at the top level of model_spec, not inside constraints) — voices[], default_voice, supports_lyrics, lyrics_required, supports_lyrics_optimizer, supports_force_instrumental, supports_speed, supports_language_code, min_speed, max_speed, min_prompt_length, prompt_character_limit. Internal TTS per-model toggles like supportsPromptParam / supportsTemperatureParam / supportsTopPParam exist on the model definitions but are not merged into /models output today — treat the speech request schema as the support matrix.
  • Embedding (top-level, not inside constraints) — embeddingDimensions, maxInputTokens, supportsCustomDimensions.

model_spec.pricing — by model family

  • LLM — input.{usd,diem}, output.{usd,diem} per 1 000 000 tokens, plus optional cache_input (reads), cache_write (writes, e.g. Anthropic 1.25×), and extended.* tier triggered by context_token_threshold.
  • Image — either generation.{usd,diem} per image (flat) or resolutions.<tier>.{usd,diem} (per 1K/2K/4K). Every image row also carries a global upscale.{2x,4x}.{usd,diem} block (derived from shared upscale SKUs) — treat it as account-wide upscale pricing, not a signal that this specific model can upscale. Combine with the inpaint/upscale model's own capability check to decide what's actually callable.
  • Inpaint / edit — inpaint.{usd,diem} per edit.
  • Video — not currently returned on /models. calculatePricing() has no video branch, so video entries have no model_spec.pricing. Use POST /video/quote for the authoritative per-request price.
  • Music / long audio — generation.{usd,diem} (per job), per_second.{usd,diem} (per second generated), per_thousand_characters.{usd,diem} (character-priced narration), or durations.<tier>.{usd,diem,min_seconds,max_seconds} (duration-bucketed).
  • TTS — input.{usd,diem} per 1 000 000 input characters.
  • ASR — per_audio_second.{usd,diem}.
  • Embeddings — input.{usd,diem} per 1 000 000 tokens.

Crypto RPC pricing is not in /models — it's tier × chain multipliers on /crypto/rpc/{network} (see venice-crypto-rpc).

Other top-level model_spec fields

FieldUse
privacy (private / anonymized)Zero data retention if private.
beta / betaModelGated to beta users (beta: true ⇒ need access).
offlineCurrently unavailable; skip.
regionRestrictions[]Country codes. 403 outside them.
deprecation.dateRetirement date. Migrate before.

GET /models/traits

curl "https://api.venice.ai/api/v1/models/traits?type=text"

Returns { object: "list", type: "text", data: { "default": "zai-org-glm-5-1", "fastest": "grok-41-fast", "most_uncensored": "venice-uncensored", "default_reasoning": "...", "default_code": "...", "default_vision": "...", "function_calling_default": "...", "most_intelligent": "..." } } for type=text. For type=image, expect keys like default, fastest, highest_quality, eliza-default. Trait keys come from the internal ApiModelTraits / LLMApiModelTraits / ImageApiModelTraits enums.

Use this to avoid hard-coding model IDs — resolve a trait at boot and cache for the session.

GET /models/compatibility_mapping

curl "https://api.venice.ai/api/v1/models/compatibility_mapping?type=text"

Returns { object: "list", type: "text", data: { "openai-gpt-54-pro": "zai-org-glm-5-1", "claude-opus-4-7": "claude-opus-4-7", "gpt-5-4-pro": "openai-gpt-54-pro", ... } }. Both OpenAI-style IDs (openai-gpt-54-pro) and vendor-style aliases (gpt-5-4-pro) may appear as keys.

Lets an OpenAI-style client call Venice with its native model IDs — Venice substitutes behind the scenes. Useful when porting existing code.

Common patterns

Pick a vision+reasoning model at runtime

const list = await fetch(`${base}/models?type=text`).then(r => r.json())
const match = list.data.find((m: any) =>
  m.model_spec.capabilities.supportsVision &&
  m.model_spec.capabilities.supportsReasoning &&
  !m.model_spec.offline &&
  !m.model_spec.beta
)

Validate an image request before submit

const spec = (await fetch(`${base}/models?type=image`).then(r => r.json()))
  .data.find((m: any) => m.id === myModel)!.model_spec

const { widthHeightDivisor, promptCharacterLimit, aspectRatios } = spec.constraints
if (prompt.length > promptCharacterLimit) throw new Error('prompt too long')
if (width % widthHeightDivisor !== 0) throw new Error('width not divisible')
if (aspectRatios && !aspectRatios.includes(myAspect)) throw new Error('bad aspect')

Estimate LLM cost

const p = spec.pricing
const cost =
  (inputTokens / 1_000_000) * p.input.usd +
  (outputTokens / 1_000_000) * p.output.usd +
  (cachedTokens / 1_000_000) * (p.cache_input?.usd ?? 0)

For extended-context runs, check if inputTokens > p.extended?.context_token_threshold and switch to p.extended.* rates.

?type=code

type=code is a convenience filter returning text models with capabilities.optimizedForCode === true. Same response shape as type=text.

Gotchas

  • The catalog changes — cache for minutes, not days.
  • beta: true models require beta-flagged keys — otherwise 401 with "only available to Pro users".
  • offline: true means the model exists in the catalog but can't currently serve requests — treat it as absent for scheduling.
  • model_spec.pricing can be missing on free / internal models — guard against undefined.
  • traits differ by type — there's no "global default"; always pass ?type=....
  • compatibility_mapping resolves model IDs, not capabilities. If your caller sends openai-gpt-54-pro but needs vision, verify via the resolved Venice model's capabilities.supportsVision.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.