DEV Community: Mason Reed

Changing Gemini CLI Directories: Workspace, Project Settings, and Global Config

Mason Reed — Tue, 22 Sep 2026 02:14:24 +0000

When I need to change a Gemini CLI directory, I first separate three tasks: starting the agent in another repository, adding repositories to its workspace, and relocating its persistent configuration. Each uses a different mechanism.

Gemini CLI is Google’s open-source terminal agent. Alongside code inspection and assistance, it can execute shell commands with safeguards and integrate tools such as Google Search and Model Context Protocol (MCP) extensions. Those capabilities make directory scope matter: the files available to the agent and the location of its credentials are separate concerns.

Here’s how I approach each case, including the version-dependent parts I would check before relying on them.

Start with the directory you actually want to change

The default user configuration directory is .gemini under your home directory:

Scope	Typical location	Purpose
User, Linux/macOS	`~/.gemini/`	User settings and persistent state
User, Windows	`%USERPROFILE%\.gemini`	Windows user settings and persistent state
Project	`.gemini/settings.json` in the project	Project-specific settings
System	OS-specific locations, such as under `/etc/` or `%PROGRAMDATA%`	System configuration, when applicable

Typical contents include settings.json, GEMINI.md, commands/, cached credentials, telemetry identifiers, and other local state. Project settings override corresponding user settings when operating in that project.

Historically, the user configuration path has been tied to the home directory and the .gemini name. I would therefore check the installed release before assuming a configuration-directory environment variable works.

For ordinary repository work, I start Gemini from the intended folder:

cd /path/to/your-project
gemini

That selects the starting working directory. It does not relocate the user configuration or credential cache.

Add another repository without moving configuration

If I only need the agent to inspect a second repository, workspace inclusion is the direct solution.

At startup:

gemini --include-directories /path/to/repo

Or inside an interactive session:

/directory add /path/to/another/project
/directory list

These commands extend the workspace context. They do not move ~/.gemini.

This is useful when a change spans an application and a shared library, or when another repository provides reference material. Moving configuration would not solve that access problem.

If a directory still appears unavailable, I check whether the CLI process can read it. Network mounts and filesystem permissions can prevent access even when the directory has been added successfully.

Don’t rely on shell-mode `cd` to switch the session

Some platforms have had issues where cd inside Gemini’s shell mode does not change the working directory as expected.

My practical workaround is to change directories in the parent terminal before launching the CLI. For additional context within an existing session, I use /directory add.

Keep repository settings with the repository

For project-specific behavior, I use a project .gemini directory instead of redirecting the global one:

your-project/
├── .gemini/
│   ├── settings.json
│   └── GEMINI.md
└── src/

Run gemini from the project directory so it can discover the project configuration and context. Context discovery can search upward through the directory tree.

This gives a repository its own settings while leaving user-wide state in the normal location. It also makes the intended scope easier to inspect: a repository override lives alongside the code it affects.

The distinction matters when debugging authentication. Adding project settings does not, by itself, move the user credential cache.

Relocate global configuration only when necessary

For a centralized configuration store, another drive, or a restricted home directory, there are two main options: a supported native override or a filesystem redirect.

Check environment-variable support for your release

Several similarly named settings serve different purposes:

GEMINI_API_KEY supplies a key for Gemini API authentication.
GEMINI_MODEL selects a model where supported.
GEMINI_CLI_SYSTEM_SETTINGS_PATH overrides the system settings file path where supported.
GEMINI_CONFIG_DIR has appeared as a code constant and in community proposals for a configurable directory.

A constant named GEMINI_CONFIG_DIR does not establish that the CLI reads an environment variable with that name. Support and behavior have varied, with Windows issues reported in particular.

If your installed version documents the directory override, the shell configuration looks like this:

export GEMINI_CONFIG_DIR="$HOME/custom_gemini_dir"
gemini

PowerShell:

$env:GEMINI_CONFIG_DIR = 'C:\Users\you\CustomGemini'
gemini

Treat those as conditional examples. Before building CI around them, check the release documentation and verify where that version actually writes its state.

The system-settings override is narrower:

export GEMINI_CLI_SYSTEM_SETTINGS_PATH="/etc/my-gemini/system.settings.json"
gemini

Even when supported, that selects a system settings file; it is not a general relocation mechanism for credentials, commands, and caches.

Use a symlink or junction when native relocation is unavailable

A filesystem redirect lets the CLI continue addressing its expected path while the directory contents live elsewhere.

On Linux or macOS, assuming the current configuration exists and the destination parent is available:

# Preserve the current configuration.
mv "$HOME/.gemini" "$HOME/gemini_backup"

# Populate the destination before linking it.
mkdir -p /path/to/central/gemini-config
cp -a "$HOME/gemini_backup/." /path/to/central/gemini-config/

ln -s /path/to/central/gemini-config "$HOME/.gemini"

On Windows, a directory junction provides a similar approach. From an appropriately privileged PowerShell session:

Move-Item -Path "$env:USERPROFILE\.gemini" -Destination 'C:\GeminiConfigBackup'

New-Item -ItemType Directory -Path 'C:\CentralGeminiConfig' -Force
Copy-Item -Path 'C:\GeminiConfigBackup\*' -Destination 'C:\CentralGeminiConfig' -Recurse -Force

New-Item -ItemType Junction `
  -Path "$env:USERPROFILE\.gemini" `
  -Target 'C:\CentralGeminiConfig'

I keep the backup until the CLI has loaded the expected settings and authentication state.

Symlinks and junctions depend on filesystem privileges and can behave differently across Windows and container environments. Some CLI versions also restrict following certain symlinks for security, so I verify both settings.json and context discovery after the move.

Treat home-directory changes as an isolated-runtime option

In CI or containers, controlling the process’s effective home directory can influence where the default .gemini path resolves. The source environment may use HOME on Unix or profile-related values on Windows.

That change has a broader effect than a configuration override: other tools and authentication flows, including Google OAuth caches, may also depend on the home directory. I would reserve this approach for an isolated runtime whose filesystem and authentication setup I control.

Diagnose failures by scope

The error usually tells me which layer to inspect.

Symptom	What I check
Another repository is invisible	`--include-directories`, `/directory add`, and read permissions
Project settings seem ignored	Launch directory and project `.gemini/settings.json`
Relocated settings are missing	Link target, copied contents, and version-specific symlink behavior
`GEMINI_CONFIG_DIR` appears ignored	Whether that release supports it as an environment variable
Windows reports `EPERM` creating `.gemini`	Write permissions on `%USERPROFILE%`

For Windows EPERM, adjusting folder permissions or using an appropriately elevated terminal can resolve the underlying access problem. A supported alternate location or junction may also help when the default profile directory is unsuitable.

Keep API routing separate from directory configuration

Sometimes the underlying goal is to use Gemini from a script or CI job. In that case, a direct API request may be sufficient, without configuring the terminal agent.

A unified multi-model API such as CometAPI exposes an OpenAI-style chat-completions endpoint using bearer authentication:

export COMET_KEY="sk-xxxx"

curl -s -X POST "https://api.cometapi.com/v1/chat/completions" \
  -H "Authorization: Bearer $COMET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-pro",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Summarize the 3 key benefits of unit tests."}
    ],
    "max_tokens": 300
  }' | jq .

This calls the model directly. It does not provide the CLI’s workspace, file inspection, or shell-tool behavior.

Connecting the official CLI to a gateway requires checking both custom-base-URL support and API compatibility. Some releases or proposals have introduced overrides such as GOOGLE_GEMINI_BASE_URL, but a base URL alone does not translate Gemini requests into OpenAI-style requests. A compatible endpoint or translating proxy is still necessary.

For model-ID mismatches, inspect the gateway’s /v1/models response and use the exact identifier. A variant such as gemini-2.5-flash-preview-04-17 should not be assumed interchangeable with a shorter family name.

For my own directory setup, I keep the choice narrow: project settings for repository behavior, workspace commands for additional files, and a verified relocation mechanism only when persistent state needs another home.

Originally published at cometapi.com

Building an AI Companion: Persona, Memory, Tools, and the Tests That Matter

Mason Reed — Mon, 21 Sep 2026 07:58:58 +0000

I’d start an AI companion with a narrow role, an explicit memory policy, and a set of difficult conversations to test. Voice and avatars come later. They make the experience more expressive, but they also make inconsistent behavior more noticeable.

The engineering work sits across several layers: personality, conversation state, persistent memory, retrieval, tool execution, and presentation. Customization means deciding how those layers work together.

Here’s how I’d approach a build in 2026, including where existing platforms make sense and where I’d want control over the backend.

Choose the relationship before the stack

“AI companion” covers several products with different requirements. I’d pick one primary role before choosing a model or writing a system prompt.

Role	Main behavior	What the implementation needs
Study coach or mentor	Structured guidance and accountability	Goals, task tracking, reminders
Social companion	Warmth, banter, conversational continuity	Preference memory and consistent tone
Wellness companion	Reflection, journaling, habit support	Clear boundaries for sensitive conversations
Creative partner	Brainstorming, stories, character development	Project context and flexible generation
Roleplay character	Consistent characterization and scene progression	Backstory, scene state, narrative memory
Productivity assistant	Planning and task execution	Calendar, document, and application integrations

Trying to cover all these roles immediately makes prompt design and evaluation harder. A study coach that gives concise guidance has a different conversational rhythm from a roleplay character.

This choice also determines what to remember. A mentor needs recurring goals. A creative partner needs project decisions. A social companion needs continuity without turning every casual statement into a permanent preference.

Decide how much infrastructure you want to own

Consumer platforms such as Replika, Character.AI, Kindroid, Nomi, and Kalon offer an accessible route to personality and visual customization. For work-oriented use cases, Zoom AI Companion, Microsoft Copilot, and custom GPTs fit more naturally into existing workflows.

A custom implementation gives you control over memory, model selection, tool permissions, and the interface. It also makes you responsible for keeping those components consistent.

Approach	Customization	Best fit	Cost model	Main advantage
Consumer apps: Kalon, Kindroid, Nomi	Personality, visuals, backstory, long-term memory	Personal and social use	Freemium or subscription	Fast setup and immersion
Zoom Custom AI Companion	Agents, knowledge, avatars	Enterprise workflows	Add-on, approximately $12/user/month	Workflow integration
Custom GPTs / Copilot	Prompts and platform-dependent memory	Productivity	Subscription	Existing ecosystem
Custom API implementation	Application-controlled persona, memory, and tools	Custom products and scaling	Pay per use	Backend flexibility
Open-source models such as Llama	Fine-tuning and self-hosted behavior	Advanced deployments and privacy requirements	Hosting and operation costs	Ownership and control

For comparing models behind one interface, a unified gateway such as CometAPI offers an OpenAI-compatible API covering 500+ models, including GPT-5, Claude, Grok, and open-source options; its advertised 20–40% savings and 1M free testing tokens are terms I’d verify against the models and workload I actually intend to use.

I’d choose the platform based on the controls the product requires. Visual customization alone is a different requirement from owning retrieval, deletion, and tool execution.

Write a persona you can evaluate

“Be helpful and friendly” leaves too much behavior unspecified.

My persona specification would include a name, role, speaking style, values, interests, emotional range, relationship dynamic, and prohibited behaviors. For a fictional character, I’d add age and backstory.

The useful details are observable. “Short answers first” is testable. “A great personality” is not.

A compact study-coach instruction might look like this:

Be a calm, empathetic study coach who gives short answers first,
adds examples only when asked, avoids slang, and checks in with
the user after stressful topics.

For a character-driven companion, the source’s Elara example provides a different starting point:

You are Elara, a witty 28-year-old astrophysicist companion who
loves sci-fi and deep conversations. You respond warmly but
directly, using analogies from space exploration.

Neither prompt defines the whole product. Memory rules, sensitive-topic behavior, and tool access still need their own specifications.

I’d compare prompt variants against the same conversations and then compare models. Claims about one model being better at empathy or creativity are useful hypotheses; the actual persona needs evaluation on its own workload.

Make memory a product feature with user controls

I’d separate memory into three layers:

Session context: the current conversation.
Persistent user memory: stable preferences, recurring goals, and relevant history.
Retrieved context: facts or documents fetched for the current response.

For a custom build, persistent recall can use a memory layer such as mem0 or a custom implementation with Upstash Redis. RAG can bring in documents and user data when needed. A user profile can hold preferences such as communication style, favorite topics, and goals.

The important design choice is what deserves persistence. Storing everything makes it harder to distinguish a lasting preference from a passing comment.

ChatGPT illustrates the controls users increasingly expect: it can reference past chats, saved memories, and, where available, files and connected Gmail. Users can delete or clear memories, disable memory, or use Temporary Chat to prevent new memories from being created. Memory-source controls can also show what context contributed to personalization.

For my own implementation, I’d make remembered information inspectable and correctable. The critical test is a preference change: when the user contradicts an older preference, does the companion follow the updated one?

Specify boundaries alongside the personality

A warm persona still needs explicit limits. I’d define what it can discuss, when it should refuse, when it should redirect, and how it should handle sensitive emotional situations.

That specification should cover unsafe advice, privacy, disallowed content, and behavior that encourages emotional dependency.

Human-like presentation increases the chance that users attribute understanding or authority to the system. The companion should remain clear about its capabilities while responding with care.

These rules belong in evaluation from the beginning. A character that follows its backstory perfectly but mishandles a distressed user is not behaving consistently with the product requirements.

Ground answers before adding actions

Knowledge retrieval and tool execution solve different problems, and I’d configure them separately.

Knowledge sources can include internal documents, project notes, or web search. Custom dictionaries help with domain terminology; Zoom’s Custom AI Companion supports knowledge bases and custom dictionaries for this kind of adaptation.

Tools let the companion act through calendars, email, or other APIs. For custom implementations, function calling or model tool use provides the integration mechanism.

Model selection matters here as much as it does for conversation. A model that produces appealing dialogue still needs evaluation on tool selection and reasoning.

I’d also keep behavioral tuning explicit:

Temperature and top-p affect sampling behavior.
Response templates and custom dictionaries can improve consistency.
User ratings provide feedback for evaluation and, where implemented, retraining or RLHF-like processes.

Routine conversation should not be described as “training” unless the application actually updates model parameters. Often the change is in stored context, prompts, or retrieval.

Add voice and visuals once the text behavior holds up

Text remains the largest AI companion segment, while Grand View Research identifies multimodal companions as the fastest-growing segment.

That direction makes sense for product design: voice changes delivery, visual identity shapes how users perceive the character, and reactions to photos or screenshots provide additional context.

I’d still introduce these features incrementally:

Stabilize text behavior and memory.
Add a visual identity or scene imagery.
Add voice.
Evaluate more dynamic avatar behavior.

Image generation and editing options named in the source include GPT-image-2, Flux, and Midjourney. Voice can use selected or cloned TTS voices with emotional inflection; ElevenLabs integrations are common. Real-time avatars responding through emotion detection are an emerging direction in products such as Genies.

Each layer needs to match the established persona. An expressive voice cannot compensate for forgotten preferences or contradictory responses.

Ship against a conversation test suite

Before deployment, I’d run the same scenarios across prompt and model changes:

Scenario	What I’d check
The user has had a bad day	Tone adapts without abandoning boundaries
Playful banter	Humor stays consistent with the persona
A sensitive emotional topic	Support and redirection follow the specification
A conversation depends on older context	Relevant memory is retrieved accurately
The user changes a preference	New information takes precedence over stale context

Track coherence, user satisfaction, and latency alongside those cases. Test model changes against the whole interaction flow, including retrieval and tools.

Deployment can be a web interface, a mobile app, or an integration into an existing product. I’d keep the first release focused enough that a failure can be traced to a specific layer: persona, memory, retrieval, tools, or presentation. That gives each subsequent iteration a concrete problem to solve.

Originally published at cometapi.com

Top 6 OpenClaw Skills you can't afford to miss in 2026

Mason Reed — Mon, 21 Sep 2026 06:58:43 +0000

OpenClaw has emerged as one of the most transformative open-source projects of 2026, powering autonomous AI agents that don't just chat—they act. Running locally on your machine or VPS, OpenClaw connects large language models (like Claude, GPT, or local alternatives) with your files, apps, browser, terminal, and messaging platforms (WhatsApp, Telegram, Discord, etc.). It handles real tasks: clearing inboxes, managing calendars, executing workflows, and running 24/7 via heartbeat schedulers.

At the heart of OpenClaw's power are Skills—modular Markdown files (typically SKILL.md) that package instructions, prompts, tool calls, and workflows. These reusable components turn a generic agent into a specialized digital coworker. With thousands available on ClawHub and community repos, selecting the right ones is critical.

What Is OpenClaw and Why Skills Matter in 2026

OpenClaw (formerly Clawdbot/Moltbot) is a self-hosted agent runtime. It runs on Mac, Windows, or Linux, connects to any LLM (OpenAI, Anthropic, local models via Ollama, etc.), and uses messaging apps as the primary interface. It features persistent local memory (Markdown files), browser automation, shell execution, and proactive scheduling.

Skills are the extensibility layer. Defined primarily via SKILL.md (natural language instructions + tool calls), they allow the LLM to interpret and execute complex, multi-step tasks reliably. Community contributions exploded in 2026, with high-quality skills vetted on ClawHub.

Key Benefits:

Modularity: Install only what you need; chain them for complex workflows.
Extensibility: Community and self-created skills allow custom behaviors.
Persistence: Combined with memory systems (e.g., MEMORY.md, SOUL.md), skills enable long-term learning.
Safety & Control: Local execution keeps data private; vet skills carefully.

Data Support: Analyses of ClawHub show native/bundled tools cover ~70% of calls, but top community skills handle high-value tasks like email, browsing, and project management. Users report 90-day reliability improvements and significant time savings.

Installation Basics (General for Most Skills):

Ensure OpenClaw is installed and running (Docker, direct install, or VPS recommended).
Use the ClawHub CLI or manual placement in the skills directory.
Restart/reload the agent and test via your preferred chat app.
Configure API keys (e.g., for external services) in environment variables or config files.

Pro Recommendation: Power OpenClaw with CometAPI . This single OpenAI-compatible endpoint provides access to 500+ models (GPT-5 series, Claude Opus/Sonnet variants, Grok, DeepSeek, Llama, multimodal, etc.) at 20–40% lower costs, with free starter tokens. It eliminates multiple API keys, offers enterprise analytics/privacy controls, and ensures high uptime—perfect for always-on OpenClaw agents. Integrate once and route models dynamically for optimal cost/performance (e.g., cheaper models for routine tasks, frontier for complex reasoning).

1. GOG (Google Workspace Integration) — The Productivity Powerhouse

What it is: GOG (often steipete/gog or similar wrappers) provides unified access to Gmail, Calendar, Drive, Docs, Sheets, and Contacts via Google’s APIs/CLI.

Importance: Email and calendar management consume ~28% of knowledge workers’ time. GOG automates triage, scheduling, and data synthesis. It ranks among the most-installed skills (tens of thousands of downloads) and powers “AI employee” workflows.

How to install:

clawhub install gog (or official variants).
Authenticate via OAuth (use dedicated/scoped accounts for safety).
Add to workspace and test with “Summarize my unread emails.”

Key Functions:

Intelligent inbox triage, auto-archive, replies/drafts.
Calendar conflict detection, meeting scheduling, reminders.
Drive/Docs/Sheets: Search, summarize, update data, generate reports.
Proactive briefings (e.g., morning digest combining email + calendar + Drive files).

Use Cases & Data:

Founders: Auto-coordinate meetings and update Notion/Sheets CRMs.
Teams: Weekly status reports pulled from emails/Docs.
Personal: Flight check-ins or expense tracking from receipts in Drive. Real-world impact: Users achieve inbox zero and reclaim hours; integration with CometAPI allows cheaper models for high-volume email processing.

CometAPI Tip: Route routine summarization to cost-effective models while using premium ones for sensitive drafting.

2. Agent Browser / Web Automation Skill — Autonomous Internet Agent

What it is: Tools like Agent Browser or Playwright-based skills enable headless browsing, form filling, scraping, screenshots, and interaction with JS-heavy sites.

Importance: Web tasks (research, monitoring, transactions) are fragmented. This skill turns OpenClaw into a true agent, with high adoption for research and ops automation.

How to install:

clawhub install agent-browser (or top-rated equivalents).
Configure in sandbox (Docker recommended due to power).
Test: “Check flight status and summarize prices.”

Key Functions:

Navigate sites, handle logins (with care), extract structured data.
Automated check-ins, lead gen, price monitoring.
Screenshots + OCR for visual confirmation.
Multi-step workflows (e.g., research → fill form → confirm).

Use Cases:

Competitive intelligence: Daily SERP/competitor monitoring.
E-commerce: Price alerts, order tracking.
Research: Compile reports from multiple sources. Data shows web skills among top installs; combined with CometAPI’s fast models, it enables real-time loops without rate limits.

Security: Sandbox heavily; use approval for actions involving logins.

3. Self-Improving Agent / Capability Evolver — The Meta-Skill

What it is: Skills like Self-Improving Agent or Capability Evolver log interactions, errors, and preferences to refine behavior autonomously.

Importance: Static agents plateau; these create compounding intelligence. Highest-rated on ClawHub with strong community backing.

How to install:

clawhub install self-improving-agent or capability-evolver.
Point to memory folders; enable in SOUL.md.

Key Functions:

Persistent learning: Update preferences, avoid repeated mistakes.
Auto-generate or refine other skills.
Memory ontology for long-term context.
Error logging and self-correction loops.

Use Cases:

Personalization: Learns your style for emails/content.
Workflow evolution: Turns ad-hoc tasks into reusable automations.
Long-running agents: Improves over weeks/months. Users report significant gains in reliability; pair with CometAPI for diverse model routing to accelerate learning.

4. GitHub Integration — Developer and Team Workflow Accelerator

What it is: Official/community GitHub skills for repo management, PRs, issues, and commits.

Importance: Dev teams spend heavily on context-switching. This skill automates reviews, notifications, and maintenance—critical as AI coding scales in 2026.

How to install:

clawhub install github.
OAuth setup with scoped tokens.

Key Functions:

Monitor PRs/issues, auto-summarize, suggest reviewers.
Create branches, draft PRs, run basic CI checks.
Daily digests and triage from chat.
Code review assistance.

Use Cases:

Solo devs: “Fix failing tests” → autonomous loops.
Teams: Auto-close stale issues, generate release notes.
Integration with browser skill for external research. High download counts; CometAPI supports strong coding models (e.g., specialized coders) at lower cost.

5. Summarize Skill — Knowledge Distiller

What it is: Universal summarization across URLs, YouTube, podcasts, docs, and files.

Importance: Information overload is constant. This skill (10k+ downloads) delivers concise insights fast.

How to install:

clawhub install summarize.
Simple setup; works with local files too.

Key Functions:

Multi-format input → structured output (key points, action items).
Custom rubrics (e.g., “business implications”).
Batch processing for newsletters/research.
Integration with other skills (e.g., summarize then act).

Use Cases:

Daily news/podcast digests via heartbeats.
Meeting prep: Summarize related docs.
Research pipelines. Essential baseline skill; efficient with CometAPI’s balanced models.

6. Project Management Integrations (e.g., Linear, Notion) — Ops Orchestrator

What it is: Skills for Linear, Notion, Asana, etc., syncing tasks across tools.

Importance: Fragmented tools kill productivity. These unify execution.

How to install:

e.g., clawhub install linear or Notion equivalents.
API key/OAuth.

Key Functions:

Create/update tickets from chat/emails.
Status sync and cross-tool reports.
Auto-triage bugs from logs/emails.
Weekly digests and reminders.

Use Cases:

Founders: Link emails → tasks → Notion.
Teams: Standup automation.
Personal: Life admin tracking. Combines powerfully with GOG and self-improving skills.

How to choose the right OpenClaw skill

Choose skills based on repeated pain, not novelty. If a task happens every day, starts in chat, and ends with a tool action, it is a skill candidate. If it needs memory, timing, or strict guardrails, it is an even better candidate. OpenClaw’s own docs emphasize that skills teach the agent how and when to use tools, while plugins and tools provide the raw capability.

A good rule for 2026 is to start with the six skills above and then add custom workspace skills only after you have measured the pain point. OpenClaw supports local overrides, workspace skills, and precedence rules, so you do not need to keep editing the same repo copy to customize behavior.

Comparison Table: Top 6 OpenClaw Skills

Skill	Installs/Popularity	Best For	Complexity	Risk Level	CometAPI Synergy
GOG (Google)	Very High (top-ranked)	Productivity, Email/Calendar	Low-Medium	Medium (OAuth)	High (volume tasks)
Agent Browser	High	Research, Automation	Medium-High	High (sandbox)	High (real-time)
Self-Improving	High (top-rated)	Long-term Autonomy	Low	Low	Medium (learning loops)
GitHub	High	Dev Workflows	Medium	Medium	High (coding models)
Summarize	High	Knowledge Mgmt	Very Low	Low	High (efficiency)
Project Mgmt (Linear/Notion)	Medium-High	Ops/Teams	Low-Medium	Low-Medium	High (orchestration)

Skill/Category	Use Case	Install Difficulty	Popularity (Est.)	Key Benefit	CometAPI Synergy
GitHub	Repo management, PRs	Low	Very High	Autonomous dev workflows	Reliable coding models
Agent Browser	Web automation	Medium	High	Browser actions without manual	Vision/ multimodal models
Web Search	Real-time research	Low	High	Fresh data synthesis	Fast, cheap inference
Summarize/Notion	Content & knowledge mgmt	Low	High	Structured output	Long-context models (GPT-5.4)
Self-Improving	Agent evolution	Medium	Growing	Reduced errors over time	Consistent model perf via CometAPI
Calendar/Email	Daily productivity	Low	Very High	Proactive scheduling	Low-latency for frequent calls

Advanced Tips, Security, and Scaling in 2026

Memory & Heartbeats: Combine skills with persistent memory and scheduled runs for proactive agents.
Security Best Practices: Dedicated user/sandbox, VirusTotal checks on ClawHub, approval gates, read-only defaults, regular audits. Consider NVIDIA NemoClaw for added guardrails.
Multi-Agent Setups: Run specialized OpenClaw instances (e.g., one for coding, one for personal).
CometAPI Integration: Set as primary provider in OpenClaw config. Use model routing for cost optimization (e.g., via their dashboard analytics). Benefits: Single key, broad model access (including latest releases), lower latency/cost, privacy focus. Ideal for high-token agents.
Building Custom Skills: OpenClaw can help generate them—start simple with SKILL.md.

Future Outlook: By late 2026, expect deeper multimodal skills, better enterprise controls, and even more seamless integrations. Skills like these position you at the forefront.

Conclusion: Level Up Your OpenClaw Today

These top 6 skills—GOG, Agent Browser, Self-Improving/Capability Evolver, GitHub, Summarize, and Project Management—form a robust foundation for a truly autonomous AI teammate in 2026. Start with core productivity ones (GOG + Summarize), then layer on automation and self-improvement.

Ready to deploy? Head to openclaw.ai, install via the one-liner, and power it with CometAPI at cometapi.com for seamless, affordable access to the best models. Experiment safely, iterate with your agent, and watch productivity soar.

Originally published at cometapi.com

How to Add AI Video Generation to a SaaS App

Mason Reed — Mon, 21 Sep 2026 04:40:33 +0000

Adding video generation to your app is not the same as adding image generation. The API call returns immediately — but the video isn't ready yet. You get a task ID, and you have to keep asking "is it done?" until it is.

Most developers hit this the first time they call a video API, wait for a response body with a video URL, and get back a task ID instead. This guide walks through the full flow: submitting a task, polling for results, handling failures, and storing the output before the URL expires.

What you'll build

A backend service that accepts a text prompt or image, submits a video generation task, polls until it's complete, and returns the final video URL. You'll work with four models — Veo 3 Fast, Sora 2, Kling Video, and Runway — all through a single API key.

Prerequisites:

Python 3.8+ or Node.js 18+
A CometAPI key
Basic familiarity with REST APIs

Understand why video generation is different

With image generation, you send a request and get the image back in the same response. Video generation uses an async task queue:

Submit a generation request → get back a task_id
Poll a status endpoint every few seconds
When status reaches a terminal state, you get the video URL
Download and store the video — the URL is temporary

If you treat video generation like image generation and wait for the first response to contain your video, your request will time out every time.

In a production web service, this polling loop should run in a background worker (Celery, Bull, or similar), not in your request handler. The examples below use synchronous polling — fine for scripts and prototypes, but not for handling concurrent users.

Choose a model

Model	Provider	Max duration	Price (via CometAPI)	Best for
Veo 3 Fast	Google	8 sec	$0.05/sec	Fast prototyping, social clips
Sora 2	OpenAI (via CometAPI model ID)	~10 sec	$0.08/sec	High-quality creative shorts
Kling Video	Kuaishou	10 sec	$0.13–$2.64/task	Marketing content, granular control
Runway Gen-3A Turbo	Runway	5 or 10 sec	$0.32/task	Image-to-video, commercial content

Source**: CometAPI model pages, May 2026. Note: "Sora 2" is CometAPI's model identifier — refer to their model page for the underlying model details.

Veo 3 Fast supports both text-to-video and image-to-video. Cheapest per second, good starting point.
Sora 2 generates audio natively alongside the video — dialogue, ambient sound, and effects without a separate TTS step.
Kling Video gives you negative_prompt, cfg_scale, camera movement settings, and a pro mode. Most control of the four.
Runway is image-to-video only via CometAPI. Give it a static image and a motion description, and it animates it.

Submit a Veo task

Veo uses multipart/form-data. Use files= in Python requests to send it correctly — data=dict sends application/x-www-form-urlencoded, which is not the same thing:

import requestsimport osfrom dotenv import load_dotenvload_dotenv()def submit_veo_task(prompt: str, size: str = "16x9") -&gt; str: &nbsp; &nbsp;"""Submit a Veo 3 Fast text-to-video task. Returns task_id.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;response = requests.post( &nbsp; &nbsp; &nbsp; &nbsp;"https://api.cometapi.com/v1/videos", &nbsp; &nbsp; &nbsp; &nbsp;headers={"Authorization": f"Bearer {api_key}"}, &nbsp; &nbsp; &nbsp; &nbsp;files={ &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"prompt": (None, prompt), &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"model": (None, "veo3-fast"), &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"size": (None, size) &nbsp; &nbsp; &nbsp;  }, &nbsp; &nbsp; &nbsp; &nbsp;timeout=30 &nbsp;  ) &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp;return response.json()["id"]task_id = submit_veo_task("A paper kite drifting above a wheat field on a windy afternoon")print(f"Task submitted: {task_id}")

Poll for the result

import timedef poll_veo_task(task_id: str, interval: int = 10, max_wait: int = 600) -&gt; str: &nbsp; &nbsp;"""Poll until Veo task completes. Returns video URL.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;headers = {"Authorization": f"Bearer {api_key}"} &nbsp; &nbsp;url = f"https://api.cometapi.com/v1/videos/{task_id}" &nbsp; &nbsp;elapsed = 0 &nbsp; &nbsp;while elapsed &lt; max_wait: &nbsp; &nbsp; &nbsp; &nbsp;response = requests.get(url, headers=headers, timeout=30) &nbsp; &nbsp; &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp; &nbsp; &nbsp;result = response.json() &nbsp; &nbsp; &nbsp; &nbsp;status = result.get("status") &nbsp; &nbsp; &nbsp; &nbsp;if status == "succeeded": &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;return result["output"][0] &nbsp; &nbsp; &nbsp; &nbsp;elif status in ("failed", "cancelled"): &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;raise RuntimeError( &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;f"Task {task_id} failed with status '{status}': " &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;f"{result.get('error', 'no error detail returned')}" &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;  ) &nbsp; &nbsp; &nbsp; &nbsp;time.sleep(interval) &nbsp; &nbsp; &nbsp; &nbsp;elapsed += interval &nbsp; &nbsp;raise TimeoutError(f"Task {task_id} did not complete within {max_wait} seconds")video_url = poll_veo_task(task_id)print(f"Video ready: {video_url}")

Use Kling Video for more control

Kling has a different endpoint structure and uses JSON. Note that Kling's terminal status string is "succeed" (not "succeeded") — this matches the API's actual response format:

def submit_kling_task(prompt: str, duration: str = "5", mode: str = "std") -&gt; str: &nbsp; &nbsp;"""Submit a Kling text-to-video task. Returns task_id.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;response = requests.post( &nbsp; &nbsp; &nbsp; &nbsp;"https://api.cometapi.com/kling/v1/videos/text2video", &nbsp; &nbsp; &nbsp; &nbsp;headers={ &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"Authorization": f"Bearer {api_key}", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"Content-Type": "application/json" &nbsp; &nbsp; &nbsp;  }, &nbsp; &nbsp; &nbsp; &nbsp;json={ &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"model_name": "kling-v1-6", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"prompt": prompt, &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"negative_prompt": "blurry, low quality, watermark", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"cfg_scale": 0.5, &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"mode": mode, &nbsp; &nbsp; &nbsp; &nbsp; # "std" or "pro" &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"aspect_ratio": "16:9", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"duration": duration &nbsp;# "5" or "10" &nbsp; &nbsp; &nbsp;  }, &nbsp; &nbsp; &nbsp; &nbsp;timeout=30 &nbsp;  ) &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp;return response.json()["data"]["task_id"]def poll_kling_task(task_id: str, interval: int = 10, max_wait: int = 600) -&gt; str: &nbsp; &nbsp;"""Poll Kling task until complete. Returns video URL.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;headers = {"Authorization": f"Bearer {api_key}"} &nbsp; &nbsp;url = f"https://api.cometapi.com/kling/v1/videos/text2video/{task_id}" &nbsp; &nbsp;elapsed = 0 &nbsp; &nbsp;while elapsed &lt; max_wait: &nbsp; &nbsp; &nbsp; &nbsp;response = requests.get(url, headers=headers, timeout=30) &nbsp; &nbsp; &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp; &nbsp; &nbsp;result = response.json() &nbsp; &nbsp; &nbsp; &nbsp;status = result["data"]["task_status"] &nbsp; &nbsp; &nbsp; &nbsp;if status == "succeed": &nbsp;# Kling uses "succeed", not "succeeded" &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;return result["data"]["task_result"]["videos"][0]["url"] &nbsp; &nbsp; &nbsp; &nbsp;elif status == "failed": &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;error_detail = result.get("data", {}).get("task_result", "no detail") &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;raise RuntimeError( &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;f"Kling task {task_id} failed: {error_detail}" &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;  ) &nbsp; &nbsp; &nbsp; &nbsp;time.sleep(interval) &nbsp; &nbsp; &nbsp; &nbsp;elapsed += interval &nbsp; &nbsp;raise TimeoutError(f"Kling task {task_id} timed out after {max_wait}s")

Source**: CometAPI Kling Video docs

Animate a static image with Runway

Runway is image-to-video only. It also requires an extra header (X-Runway-Version):

def submit_runway_task(image_url: str, motion_prompt: str, duration: int = 5) -&gt; str: &nbsp; &nbsp;"""Submit a Runway image-to-video task. Returns task_id.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;response = requests.post( &nbsp; &nbsp; &nbsp; &nbsp;"https://api.cometapi.com/runwayml/v1/image_to_video", &nbsp; &nbsp; &nbsp; &nbsp;headers={ &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"Authorization": f"Bearer {api_key}", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"X-Runway-Version": "2024-11-06", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"Content-Type": "application/json" &nbsp; &nbsp; &nbsp;  }, &nbsp; &nbsp; &nbsp; &nbsp;json={ &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"model": "gen3a_turbo", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"promptImage": image_url, &nbsp;# must be a stable HTTPS URL &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"promptText": motion_prompt, &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"duration": duration, &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"ratio": "1280:720", &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"watermark": False &nbsp; &nbsp; &nbsp;  }, &nbsp; &nbsp; &nbsp; &nbsp;timeout=30 &nbsp;  ) &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp;return response.json()["id"]def poll_runway_task(task_id: str, interval: int = 5, max_wait: int = 600) -&gt; str: &nbsp; &nbsp;"""Poll Runway task. Returns video URL when done.""" &nbsp; &nbsp;api_key = os.getenv("COMETAPI_KEY") &nbsp; &nbsp;if not api_key: &nbsp; &nbsp; &nbsp; &nbsp;raise ValueError("COMETAPI_KEY environment variable is not set") &nbsp; &nbsp;headers = { &nbsp; &nbsp; &nbsp; &nbsp;"Authorization": f"Bearer {api_key}", &nbsp; &nbsp; &nbsp; &nbsp;"X-Runway-Version": "2024-11-06" &nbsp;  } &nbsp; &nbsp;url = f"https://api.cometapi.com/runwayml/v1/tasks/{task_id}" &nbsp; &nbsp;elapsed = 0 &nbsp; &nbsp;while elapsed &lt; max_wait: &nbsp; &nbsp; &nbsp; &nbsp;response = requests.get(url, headers=headers, timeout=30) &nbsp; &nbsp; &nbsp; &nbsp;response.raise_for_status() &nbsp; &nbsp; &nbsp; &nbsp;result = response.json() &nbsp; &nbsp; &nbsp; &nbsp;status = result.get("status") &nbsp; &nbsp; &nbsp; &nbsp;if status == "task_not_exist": &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;# CometAPI-specific: task is still initializing, retry after a few seconds &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;time.sleep(interval) &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;elapsed += interval &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;continue &nbsp; &nbsp; &nbsp; &nbsp;elif status == "succeeded": &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;return result["output"][0] &nbsp; &nbsp; &nbsp; &nbsp;elif status in ("failed", "cancelled"): &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;raise RuntimeError(f"Runway task {task_id} failed: {result.get('error', 'no detail')}") &nbsp; &nbsp; &nbsp; &nbsp;time.sleep(interval) &nbsp; &nbsp; &nbsp; &nbsp;elapsed += interval &nbsp; &nbsp;raise TimeoutError(f"Runway task {task_id} timed out after {max_wait}s")

Source**: CometAPI Runway docs

Save the video before the URL expires

Video URLs from generation APIs are temporary. Download the file immediately and store it somewhere you control:

import requestsimport pathlibdef download_video(url: str, output_path: str) -&gt; None: &nbsp; &nbsp;"""Download video from URL to local file using streaming.""" &nbsp; &nbsp;out = pathlib.Path(output_path) &nbsp; &nbsp;if out.parent != pathlib.Path("."): &nbsp; &nbsp; &nbsp; &nbsp;out.parent.mkdir(parents=True, exist_ok=True) &nbsp; &nbsp;with requests.get(url, stream=True, timeout=60) as r: &nbsp; &nbsp; &nbsp; &nbsp;r.raise_for_status() &nbsp; &nbsp; &nbsp; &nbsp;with open(out, "wb") as f: &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;for chunk in r.iter_content(chunk_size=8192): &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;f.write(chunk) &nbsp; &nbsp;print(f"Saved to {output_path}")# Full flowtask_id = submit_veo_task("A timelapse of clouds moving over a city skyline")video_url = poll_veo_task(task_id)download_video(video_url, "output/city_timelapse.mp4")

In production, swap the local file write for an upload to S3, Cloudflare R2, or your storage of choice. The streaming pattern stays the same — pipe the bytes directly rather than loading the whole video into memory.

Handle failures

Symptom	Likely cause	Fix
Task stuck in queued for 10+ min	Server load or model unavailable	Retry with a different model
task_not_exist on first Runway poll	Task still initializing	Wait 5 sec and retry — documented CometAPI behavior
failed with no error message	Prompt triggered content filter	Rephrase the prompt
Video URL returns 403	URL expired before download	Download immediately after getting the URL
Timeout after 10 min	Generation took too long	Increase max_wait or switch to Veo 3 Fast
Kling returns "succeed" not "succeeded"	Kling's API uses non-standard status string	This is correct — see Kling polling code above

Source: CometAPI video generation docs

Node.js version

Node.js 18+ includes fetch and FormData natively. This example covers all four models:

// Node.js 18+ — no extra packages neededconst API_KEY = process.env.COMETAPI_KEY;if (!API_KEY) throw new Error('COMETAPI_KEY is not set');// --- Veo 3 Fast ---async function submitVeoTask(prompt, size = '16x9') { &nbsp;const form = new FormData(); &nbsp;form.append('prompt', prompt); &nbsp;form.append('model', 'veo3-fast'); &nbsp;form.append('size', size); &nbsp;const res = await fetch('https://api.cometapi.com/v1/videos', { &nbsp; &nbsp;method: 'POST', &nbsp; &nbsp;headers: { 'Authorization': `Bearer ${API_KEY}` }, &nbsp; &nbsp;body: form  }); &nbsp;if (!res.ok) throw new Error(`Veo submit failed: ${res.status}`); &nbsp;return (await res.json()).id;}async function pollVeoTask(taskId, intervalMs = 10000, maxWaitMs = 600000) { &nbsp;let elapsed = 0; &nbsp;while (elapsed &lt; maxWaitMs) { &nbsp; &nbsp;const res = await fetch(`https://api.cometapi.com/v1/videos/${taskId}`, { &nbsp; &nbsp; &nbsp;headers: { 'Authorization': `Bearer ${API_KEY}` } &nbsp;  }); &nbsp; &nbsp;if (!res.ok) throw new Error(`Poll failed: ${res.status}`); &nbsp; &nbsp;const result = await res.json(); &nbsp; &nbsp;if (result.status === 'succeeded') return result.output[0]; &nbsp; &nbsp;if (['failed', 'cancelled'].includes(result.status)) { &nbsp; &nbsp; &nbsp;throw new Error(`Task ${taskId} failed: ${result.error ?? 'no detail'}`); &nbsp;  } &nbsp; &nbsp;await new Promise(r =&gt; setTimeout(r, intervalMs)); &nbsp; &nbsp;elapsed += intervalMs;  } &nbsp;throw new Error(`Task ${taskId} timed out`);}// --- Kling Video ---async function submitKlingTask(prompt, duration = '5', mode = 'std') { &nbsp;const res = await fetch('https://api.cometapi.com/kling/v1/videos/text2video', { &nbsp; &nbsp;method: 'POST', &nbsp; &nbsp;headers: { &nbsp; &nbsp; &nbsp;'Authorization': `Bearer ${API_KEY}`, &nbsp; &nbsp; &nbsp;'Content-Type': 'application/json' &nbsp;  }, &nbsp; &nbsp;body: JSON.stringify({ &nbsp; &nbsp; &nbsp;model_name: 'kling-v1-6', &nbsp; &nbsp; &nbsp;prompt, &nbsp; &nbsp; &nbsp;negative_prompt: 'blurry, low quality, watermark', &nbsp; &nbsp; &nbsp;cfg_scale: 0.5, &nbsp; &nbsp; &nbsp;mode, &nbsp; &nbsp; &nbsp;aspect_ratio: '16:9', &nbsp; &nbsp; &nbsp;duration &nbsp;  })  }); &nbsp;if (!res.ok) throw new Error(`Kling submit failed: ${res.status}`); &nbsp;return (await res.json()).data.task_id;}async function pollKlingTask(taskId, intervalMs = 10000, maxWaitMs = 600000) { &nbsp;let elapsed = 0; &nbsp;while (elapsed &lt; maxWaitMs) { &nbsp; &nbsp;const res = await fetch( &nbsp; &nbsp; &nbsp;`https://api.cometapi.com/kling/v1/videos/text2video/${taskId}`, &nbsp; &nbsp;  { headers: { 'Authorization': `Bearer ${API_KEY}` } } &nbsp;  ); &nbsp; &nbsp;if (!res.ok) throw new Error(`Kling poll failed: ${res.status}`); &nbsp; &nbsp;const result = await res.json(); &nbsp; &nbsp;const status = result.data.task_status; &nbsp; &nbsp;if (status === 'succeed') return result.data.task_result.videos[0].url; &nbsp; &nbsp;if (status === 'failed') { &nbsp; &nbsp; &nbsp;throw new Error(`Kling task ${taskId} failed: ${JSON.stringify(result.data.task_result ?? 'no detail')}`); &nbsp;  } &nbsp; &nbsp;await new Promise(r =&gt; setTimeout(r, intervalMs)); &nbsp; &nbsp;elapsed += intervalMs;  } &nbsp;throw new Error(`Kling task ${taskId} timed out`);}// --- Runway (image-to-video) ---async function submitRunwayTask(imageUrl, motionPrompt, duration = 5) { &nbsp;const res = await fetch('https://api.cometapi.com/runwayml/v1/image_to_video', { &nbsp; &nbsp;method: 'POST', &nbsp; &nbsp;headers: { &nbsp; &nbsp; &nbsp;'Authorization': `Bearer ${API_KEY}`, &nbsp; &nbsp; &nbsp;'X-Runway-Version': '2024-11-06', &nbsp; &nbsp; &nbsp;'Content-Type': 'application/json' &nbsp;  }, &nbsp; &nbsp;body: JSON.stringify({ &nbsp; &nbsp; &nbsp;model: 'gen3a_turbo', &nbsp; &nbsp; &nbsp;promptImage: imageUrl, &nbsp; &nbsp; &nbsp;promptText: motionPrompt, &nbsp; &nbsp; &nbsp;duration, &nbsp; &nbsp; &nbsp;ratio: '1280:720', &nbsp; &nbsp; &nbsp;watermark: false &nbsp;  })  }); &nbsp;if (!res.ok) throw new Error(`Runway submit failed: ${res.status}`); &nbsp;return (await res.json()).id;}async function pollRunwayTask(taskId, intervalMs = 5000, maxWaitMs = 600000) { &nbsp;let elapsed = 0; &nbsp;while (elapsed &lt; maxWaitMs) { &nbsp; &nbsp;const res = await fetch( &nbsp; &nbsp; &nbsp;`https://api.cometapi.com/runwayml/v1/tasks/${taskId}`, &nbsp; &nbsp;  { headers: { 'Authorization': `Bearer ${API_KEY}`, 'X-Runway-Version': '2024-11-06' } } &nbsp;  ); &nbsp; &nbsp;if (!res.ok) throw new Error(`Runway poll failed: ${res.status}`); &nbsp; &nbsp;const result = await res.json(); &nbsp; &nbsp;const status = result.status; &nbsp; &nbsp;if (status === 'task_not_exist') { &nbsp; &nbsp; &nbsp;// CometAPI-specific: task still initializing &nbsp; &nbsp; &nbsp;await new Promise(r =&gt; setTimeout(r, intervalMs)); &nbsp; &nbsp; &nbsp;elapsed += intervalMs; &nbsp; &nbsp; &nbsp;continue; &nbsp;  } &nbsp; &nbsp;if (status === 'succeeded') return result.output[0]; &nbsp; &nbsp;if (['failed', 'cancelled'].includes(status)) { &nbsp; &nbsp; &nbsp;throw new Error(`Runway task ${taskId} failed: ${result.error ?? 'no detail'}`); &nbsp;  } &nbsp; &nbsp;await new Promise(r =&gt; setTimeout(r, intervalMs)); &nbsp; &nbsp;elapsed += intervalMs;  } &nbsp;throw new Error(`Runway task ${taskId} timed out`);}// Usage exampleconst taskId = await submitVeoTask('A paper kite drifting above a wheat field');const videoUrl = await pollVeoTask(taskId);console.log('Video ready:', videoUrl);

What's next

You now have working code for four video models, a polling loop that handles failures, and a download step that keeps you from losing generated content.

The next problem most developers hit: they've hardcoded one model, and switching to a cheaper or faster option means touching multiple files. The next article covers how to route requests across models without rewriting your code.

Next: How to Switch Between AI Models Without Rewriting Your Code

FAQ

Q: Why do I get a task ID instead of a video in the API response?

Video generation is async — models like Veo, Sora, Kling, and Runway take 2–5 minutes to render. The API returns a task ID immediately so your request doesn't time out. You poll a separate status endpoint until the task reaches a terminal state (succeeded, succeed, failed).

Q: How long does a generated video URL stay valid?

Video URLs from generation APIs are temporary. Download the file immediately after getting the URL and store it in your own storage (S3, Cloudflare R2, etc.). Don't store the URL and expect it to work hours later.

Q: What's the difference between Veo 3 Fast and Kling Video?

Veo 3 Fast is cheaper ($0.05/sec), faster, and simpler to call. Kling Video gives you more control: negative_prompt, cfg_scale, camera movement settings, and a pro quality mode. If you need to fine-tune the output, use Kling. If you need speed and low cost, use Veo 3 Fast.

Q: Can I generate video from an image instead of a text prompt?

Yes. Veo supports image-to-video by passing an input_reference file. Kling supports it via the /kling/v1/videos/image2video endpoint with an image parameter (URL or base64). Runway is image-to-video only — it doesn't accept text-only prompts via CometAPI.

Q: Why does Runway return `task_not_exist` on the first poll?

This is documented CometAPI behavior — the task is still initializing on the backend. Wait a few seconds and retry. It's not an error. The polling code above handles this automatically.

Q: Why does Kling use `"succeed"` instead of `"succeeded"`?

That's Kling's actual API response format. It's not a typo. Veo and Runway use "succeeded" — Kling uses "succeed". If you're building a unified polling wrapper, you'll need to handle both strings.

Q: Is the synchronous polling loop safe to use in a web server?

No. The polling loop in this guide blocks the thread for minutes at a time. In a real web service with concurrent users, run the polling in a background worker (Celery for Python, Bull for Node.js). Submit the task in the request handler, return the task ID to the client, and let the worker notify the client when the video is ready.

Originally published at cometapi.com

The Hidden Cost of Juggling OpenAI, Anthropic, and Google Credentials

Mason Reed — Mon, 21 Sep 2026 04:17:59 +0000

Multi-provider AI setups don't show their cost in the API bill — they show it in developer hours. Once you put a number on it, the case for consolidation stops being a matter of taste and becomes a line item your finance team can defend.

The cost most teams never count

Most product engineering teams running on top of three or four AI providers can tell you to the dollar what they spent on tokens last month. They can tell you which feature drove the most cost, which model is cheapest per million tokens, and whether their burn rate is on track for the quarter. What they usually cannot tell you is what the operational overhead of running three or four provider relationships actually costs them in developer time.

This is not because the cost is invisible. Every engineer on the team feels it. It is because the cost is paid in increments small enough to dismiss — a credential lookup here, a debugging session there, a half-day of integration work the next time a new model ships. None of these show up in any standard cost report. The API bill captures inference cost. The cloud bill captures infrastructure cost. Engineering time spent on cross-provider operational work shows up nowhere, because no system was designed to capture it. The default reporting infrastructure has a blind spot exactly the shape of this category of work.

This article is the version of that conversation that puts numbers on the table. The argument is not that multi-provider AI is bad — there are workloads where running multiple providers is genuinely the right architectural choice. The argument is that the operational cost of that choice is real, quantifiable, and usually larger than teams realise. Once you can name the figure, the architectural conversation becomes a real cost-benefit analysis instead of a series of competing intuitions.

The headline finding: For a typical five-engineer team running three AI providers, the annual operational cost of multi-provider work — counted in developer hours alone — sits between $35,000 and $60,000. That is not a hypothetical; it is what comes out when you instrument the workflow and add up the actual time. The number doesn't appear on any budget because no system was built to capture it. The case for changing your setup is what happens when you start counting it.

5 hidden line items

The operational cost of multi-provider AI work breaks down into five categories, each of which can be measured if you decide to. None of them is enormous in isolation; the cost is in the aggregate. Below, each category, what it looks like in practice, and how much time it consumes per month for a representative engineering team.

1. Initial onboarding to each provider

Setting up a new AI provider relationship is a multi-step process. Sign up for the account. Verify the email and any payment method. Read the rate-limit documentation. Set up secrets management for the new credential. Install the provider's SDK if it differs from what you already use. Wire the credential through your CI/CD pipeline so deploys can authenticate. Add the new provider to your secrets-rotation calendar. For a typical provider, this is 4–8 hours of engineering time, mostly done by one engineer but with at least some coordination overhead from others.

This cost is paid once per provider, but the "once" matters. If your team adds one new provider per year — which is below the 2026 baseline for serious teams — you pay this cost annually. The first onboarding doesn't feel expensive because it is one engineer for one afternoon. The fourth onboarding, when the same engineer has now done it four times in eighteen months and is increasingly resistant to doing it again, is where the friction shows up.

2. Monthly billing reconciliation

Every month-end, someone on the team — usually the lead engineer or technical founder — pulls usage data from each provider's dashboard, normalises the formats, attributes the costs to product features or clients, and produces a consolidated view. For a team with three providers and a clean usage pattern, this is roughly 2–4 hours per month. For a team with four or more providers, or with complex cost-attribution requirements (per-feature, per-client, or per-team), it can be 6–10 hours per month.

The reconciliation work is not engineering work in any meaningful sense — it is bookkeeping done by someone who is overqualified for the task. The fact that it lands on the engineering side rather than the finance side is itself a clue that the workflow has not been designed; it has just accumulated.

3. Credential rotation and security hygiene

Good security practice requires rotating API credentials periodically — quarterly for most teams, more frequently for regulated workloads. With one provider, this is a routine 30-minute task. With three or four providers, each with its own rotation interface, its own propagation timing, and its own potential failure modes, the same task expands to several hours per cycle. Add the time spent debugging when a rotated credential doesn't propagate cleanly to a production environment, and the cost rises further. A team that rotates credentials quarterly across four providers loses 8–15 hours per year to this specific category alone.

4. Debugging auth and integration errors across providers

A request fails. Was it a rate limit? An auth error? A model deprecation? A content-policy refusal? On a single-provider setup, this is one debugging surface. On a multi-provider setup, it is multiple — and the error formats, status codes, and dashboard log layouts differ across each. The cognitive cost of switching between provider conventions during incident response is the friction point that bites worst, because it lands during exactly the moments when speed matters most. For a team with three providers, this category typically runs 2–4 hours per month — and spikes much higher when a provider has an outage or changes their auth model unexpectedly.

5. Re-evaluating model choices each time a new release lands

In 2026, new frontier model releases happen roughly every three to six weeks. Each release triggers a small evaluation cycle: read the model card, decide whether it warrants testing against your workload, set up the integration if it's from a provider you don't already have access to, run your eval suite, compare results. On a multi-provider direct setup, this cycle is 1–2 days of engineering time per release, mostly because the setup cost is non-trivial. On a single-endpoint setup with the new model already available behind the same credential, the same evaluation is 1–2 hours. The difference, multiplied by 6–10 evaluation cycles per year, is meaningful.

Putting numbers on it

The categories above are easy to describe and easy to dismiss as small. The exercise that changes the conversation is multiplying them out for a realistic team. Below, the calculation for a five-engineer product team running three AI providers — the kind of setup that has become unremarkable for AI-native startups.

Cost category	Hours per month	Hours per year	Annual cost ($)
Initial provider onboarding (1 new provider/year)	—	5 hrs	$675
Monthly billing reconciliation	3 hrs	36 hrs	$4,860
Quarterly credential rotation across 3 providers	—	12 hrs	$1,620
Debugging auth and integration errors	3 hrs	36 hrs	$4,860
New model evaluations (8 releases/year)	—	120 hrs	$16,200
Daily context-switching tax (15 min/engineer)	25 hrs	300 hrs	$40,500
Total annual operational cost	—	509 hrs	$68,715

How the numbers are calculated. Hours per month for shared work (reconciliation, debugging) are total team hours, not per-engineer. The daily context-switching tax is 15 minutes per engineer per working day, multiplied by five engineers and roughly 200 working days a year. Dollar conversion uses a fully-loaded engineering cost of $135/hour, which is a conservative figure for a mid-level engineer in the US or UK once salary, benefits, taxes, and overhead are accounted for. Adjust both the team size and the hourly rate for your specific situation; the structure of the calculation is the same.

Three observations about this table that matter more than the bottom-line number.

First, the largest line is the one teams notice least. The $40,500 daily context-switching tax — 15 minutes per engineer per day on dashboard checks, credential lookups, and cross-provider documentation — is paid in tiny enough increments that no one feels it as a cost. It is also, by a meaningful margin, the largest single item on the table. The accumulated effect of small daily frictions outweighs every other category combined.

Second, the model evaluation cost is the most strategically expensive. $16,200 a year on evaluation cycles is significant, but the real cost is the evaluations that don't happen because the setup cost makes them not worth it. Teams running multi-provider direct setups evaluate fewer new models, take longer to migrate when a better fit appears, and end up running suboptimal model choices for longer than they should. The hidden cost of slower iteration is harder to put a number on, but it is real.

Third, the calculation is conservative. The numbers above assume a team that has its multi-provider workflow working reasonably well. Teams in worse shape — with credential rotation neglected, with no consistent reconciliation cadence, with evaluation cycles that take longer because eval infrastructure isn't in place — face higher numbers. The $68,715 figure is what good operational discipline looks like; the figure for teams without it can comfortably be twice that.

Why this cost never appears on the budget

If the operational cost is this large, why does no team have a line item for it? The answer is structural, not accidental. Four reasons together explain the blind spot:

No system was built to capture this category. Time-tracking systems are built for billable client work. Engineering reporting is built for feature delivery. Cost-attribution systems are built for COGS. None of them have a natural place to record "45 minutes debugging a rate-limit issue across two providers." The work happens; the recording infrastructure for it doesn't exist.
The increments are small enough to dismiss. Each individual instance of this work is 5–30 minutes. That's below the threshold most engineers would treat as worth tracking. The cost shows up only when you add the increments across the year — which nobody does, because there's no system that does it automatically.
The work is invisible from outside the engineering team. The CTO sees feature delivery velocity. The CFO sees the API bill. Neither sees the integration overhead in between. Unless an engineer escalates the cost explicitly — and most don't, because they have built the work into their normal routine — the category remains structurally invisible to the people making the architectural decisions.
The framing is engineering culture, not finance language. Engineers describe this work as "keeping the lights on" or "normal operational overhead" — language that doesn't trigger budget scrutiny. If the same work were described as "$68,715 a year of operational integration cost," the response from leadership would be immediate. The framing controls whether the cost becomes visible.

Together, these four factors create the blind spot that makes the multi-provider operational cost so persistent. The cost is real, the impact is significant, and almost nothing in the standard reporting infrastructure surfaces it. Making the case to change your setup starts with the framing — naming the cost in finance language is what brings it into the conversation.

The break-even calculation

Once you have the annual operational cost named, the question becomes: at what team size or workload volume does consolidating to a single-endpoint setup pay back the migration cost? The migration itself is genuinely small — typically 4–16 engineering hours depending on how the existing codebase is structured. Below the break-even point, that migration cost outweighs the operational saving; above it, the saving accumulates from the first month onwards.

Working backwards from the calculation above, the break-even for a team of five engineers running three providers is approximately one month of operational saving — about $5,700 per month of reclaimed engineering time covers the entire migration cost. For smaller teams, the break-even can be longer; for larger teams, it shortens to a few weeks. Three scenarios that bracket the typical range:

Team profile	Annual operational cost (est.)	Migration cost (est.)	Break-even
Solo founder, 2 providers	$12,000	$1,000	1 month
5-engineer startup, 3 providers	$68,000	$2,000	2 weeks
12-engineer scale-up, 4 providers	$180,000	$4,000	1 week

The pattern is consistent: the larger the team and the more providers in scope, the faster the break-even. The break-even calculation also doesn't include the secondary benefits — faster model evaluation cycles, recovered focus time, fewer credential incidents — which add to the case but are harder to quantify cleanly. The migration cost is small enough that for any team running two or more providers with non-trivial volume, it pays back within the first month.

The qualitative cost

The numbers above capture the time directly spent on multi-provider operational work. They do not capture the second-order costs that show up in how the team works. These are harder to quantify but matter more in practice.

Friction in the engineering loop. When even routine work requires context-switching across provider conventions, engineers ship slower. The shipping speed cost is not the literal time spent on switching; it is the cumulative effect of fragmented attention on the rest of the day. Productivity research has been clear for decades that context-switching has a residue cost that outlasts the switch itself. The engineering team that is constantly switching between provider dashboards is the same team that gets less done in a sprint than its size would suggest.

Resistance to better choices. When evaluating a new model requires setting up a new provider relationship, the threshold for "is it worth trying?" rises. Engineers stop suggesting evaluations they would otherwise have run. The result is that the team's model choices drift from optimal — not because anyone made a bad decision, but because the better decisions never got made. This is the failure mode that is hardest to see in retrospect because the alternative was never tested.

Burnout from administrative work. The work of managing multiple providers is genuinely tedious. Engineers tolerate it for a while, then start to resent it. The resentment shows up in standups, in slower responses to operational questions, in engineers proposing architectural changes whose real driver is escape from the credential-management overhead. The hidden cost shows up as morale, retention, and team velocity — and by the time those metrics are bad enough to notice, they have been bad for months.

The case to bring to your team

If the calculation above lines up with your team's reality and you want to make the case for consolidating, here is a practical framing that works in internal conversations:

Lead with the dollar figure, not the engineering complaint. "Our current multi-provider setup is costing us roughly $X in engineering time per year" lands very differently to "managing credentials is annoying." The first triggers cost-benefit analysis; the second triggers a polite acknowledgment and no action.
Show your work on the calculation. Use the table structure from this article, adapted to your team's actual hours and hourly rate. The credibility of the number depends on the methodology being transparent. "Here's what we counted, here's the rate we used, here's how it adds up" is much more defensible than a single dollar figure asserted without breakdown.
Name the secondary benefits separately. The break-even pays back in dollars terms within weeks for most teams. The secondary benefits — faster model evaluation, recovered focus time, reduced credential-incident risk — are presented as additional upside, not as the core case. This keeps the primary argument financially defensible while giving the team the qualitative case they care about.
Be honest about what doesn't change. Aggregating to a single endpoint does not eliminate compliance obligations, does not change underlying model quality, and does not solve every operational problem. Naming these limits up front is what makes the rest of the argument trustworthy. The team you're presenting to will trust your recommendation more if you have already named the trade-offs honestly.
Propose a phased migration, not a big bang. The most defensible proposal is to move one new feature or one experimental workload to the new setup first, measure the operational impact, then expand. This de-risks the change and gives you a real-data answer to "does this actually work for us?" within a month. Most teams that propose phased migrations get internal approval easily; teams that propose all-at-once migrations face more resistance even when the numbers are good.

Where this leaves you

The operational cost of multi-provider AI work is real, large, and structurally invisible. Most teams pay $35,000 to $60,000 per year for a setup they assume is free because none of the cost appears on any line item. Once you start counting it, the case for consolidation moves out of "engineering preference" territory and into "defensible financial decision" territory. The numbers are the lever; the case is just letting them speak.

The practical next step: Run the calculation for your team. Use the structure from this article, adapt the hours to your actual setup, and produce the annual figure. The exercise takes less than an hour and produces a number that decides the question. CometAPI is one route for the single-endpoint consolidation; the practical case is the same regardless of which aggregator you choose.

Multi-provider AI doesn't cost what the API bill says it costs. The real cost includes 500+ hours of engineering time per year on integration overhead — credential rotation, billing reconciliation, dashboard navigation, daily context-switching. At realistic engineering rates, that's $35K–$60K of cost no system was built to capture. Naming it in finance language is what brings it into the conversation; running the calculation for your team is what wins the argument.

Ready to integrate reliably? Head to CometAPI and API doc for seamless Claude Fable 5 access alongside other frontier models, unified billing, and enterprise-grade reliability. Sign up today and get started with generous credits for new users—your next breakthrough project awaits.

Originally published at cometapi.com

Seedance 2.5: What Developers Should Know Before Launch

Mason Reed — Mon, 21 Sep 2026 03:40:37 +0000

Current Status

Seedance 2.5 is ByteDance’s next-generation video generation model in the Seedance family. ByteDance announced it on June 23, 2026, at the Volcano Engine FORCE conference. As of June 30, 2026, it was reportedly in global enterprise beta, with a public launch targeted for early July 2026.

The main changes from Seedance 2.0 are:

Native single-segment generation up to 30 seconds
Support for up to 50 multimodal reference assets
More precise local editing and continuation
Improved control over motion, camera work, consistency, and pacing
Native audio-video synchronization

Seedance 2.5 accepts text alongside images, video clips, audio, and other reference material. The model is aimed at workflows that currently require stitching together several short generations and repairing inconsistencies in post-production.

Independent benchmarks for 2.5 are not yet available. Seedance 2.0, however, already performs strongly in evaluations such as the Artificial Analysis Video Arena, where its text-to-video-with-audio score was approximately 1,219 Elo.

What the Model Adds

Longer Native Clips

Most video generation systems produce native clips in the 5-15 second range. Seedance 2.5 extends that to 30 seconds in one continuous generation.

That matters for scenes with a setup, action, camera movement, and resolution. Keeping those elements in one pass should reduce stitching and preserve narrative rhythm. ByteDance demonstrations reportedly include multi-character interactions and spacecraft previsualization using 100k+ polygon models while maintaining structural integrity across the clip.

More Reference Material

Seedance 2.5 supports up to 50 multimodal references, compared with approximately 12 in Seedance 2.0.

References can include:

Character sheets and style guides
Images and product assets
Motion-reference video
Audio and music
3D greybox or pre-production material
Text instructions

The practical benefit is tighter control over characters, environments, lighting, branding, and object identity. This is particularly relevant to teams with established asset libraries.

Motion and Cinematic Control

The model is designed for more stable motion, physical interactions, lighting, and character consistency. Its control surface is intended to cover camera behavior such as dolly, tracking, and POV shots, along with performance and pacing.

Seedance 2.0 already emphasized “exceptional motion stability” and “director-level control” over performance, lighting, shadows, and camera movement. Version 2.5 appears to extend those capabilities to longer and more complex scenes.

Local Editing and Continuation

Local or region-based editing allows a team to change part of a frame without regenerating the entire video. High-quality continuation is intended to extend an existing clip while preserving its style and rhythm.

For e-commerce, this could mean generating a strong lifestyle video once and creating variants for different SKUs, backgrounds, languages, and promotions without rebuilding every scene.

Output Options

Seedance 2.5 is expected to support resolutions up to 4K, building on Seedance 2.0’s capabilities. It also supports multiple aspect ratios, including 16:9 and 9:16, for social, web, and broadcast-oriented outputs.

Seedance 2.5 Compared with 2.0

Seedance 2.0 already supports text, image, audio, and video inputs through a unified audio-video generation architecture. The newer model mainly addresses duration, reference capacity, editing, and production control.

Feature	Seedance 2.0	Seedance 2.5	Practical effect
Native clip length	Approximately 5-15 seconds	Up to 30 seconds in one pass	Fewer stitches and better continuity
Maximum references	Up to approximately 12 multimodal inputs	Up to 50 multimodal inputs	More control over identity, style, and branding
Editing	Basic refinement	Local or region editing with improved consistency	More targeted iteration
Resolution	Up to 1080p/4K options	Enhanced native 4K support	Sharper production output
Continuation	Limited	Higher-quality continuation with rhythmic consistency	Easier longer-form work
Prompt adherence	Strong	Approximately 20% better, as reported	Potentially fewer retries
Typical use	Short clips and basic multimodal work	Cinematic scenes, previsualization, and branded long-form content	Broader professional use

The reported improvement figures are vendor-reported. Generation speed, failure rates, and independent quality metrics still need to be validated after public release.

Release Timeline

ByteDance previewed Seedance 2.5 in late June 2026 at the Volcano Engine conference. The expected public launch window is early July 2026, following an enterprise beta and expansion through platforms such as Dreamina, CapCut, and API providers.

As of late June 2026, access remained limited. Developers should verify model availability, pricing, and exact output specifications before committing to a production workflow.

Calling the Video Endpoint

For an OpenAI-compatible video workflow, the request can look like this:

import os
import requests

response = requests.post(
    "https://api.cometapi.com/v1/videos",
    headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
    data={
        "prompt": "A slow cinematic camera push across a coastal landscape at sunrise",
        "model": "doubao-seedance-2-0",
        "seconds": "4",
        "size": "16:9",
    },
    timeout=30,
)

response.raise_for_status()
print(response.json())

A unified multi-model API such as CometAPI is useful here when the application needs one integration point for text, image, and video models, or when it needs to switch between Seedance versions during evaluation and rollout.

For multimodal references, add an input_reference file for image-guided generation. Advanced multi-reference requests can repeat the same multipart fields in upload order. The uploaded files can then be referenced sequentially as [Image 1], [Image 2], and [Image 3], with a specific role assigned to each image in the prompt.

Video generation is asynchronous. Submit the task, retain its ID, and poll the video status endpoint:

GET /v1/videos/

The Seedance query endpoint returns the current task status, progress, and the signed video URL after completion. The documented polling flow works for Seedance 1.0 Pro, 1.5 Pro, and 2.0. Node.js and cURL clients use the same request shape with the appropriate base URL and credentials.

Practical Workloads

Social Advertising

A 30-second clip can contain the hook, problem, product reveal, proof point, lifestyle shot, and call to action in one generation. Teams can then create variants by audience, region, aspect ratio, product, or visual style.

Product and E-Commerce Video

Reference-driven generation can turn catalog images into lifestyle scenes for seasonal campaigns, marketplace listings, product pages, and localized promotions. Human review remains necessary, but the approach can reduce the time needed for initial concepts and variant production.

Storyboards and Previsualization

Film, animation, and agency teams can explore camera movement, blocking, lighting, pacing, and visual style before committing to a shoot or full production. A 30-second draft can also support pitches and client approvals.

Training and Education

Short generated videos fit onboarding, safety explanations, product walkthroughs, classroom examples, and internal training. Multimodal references make it possible to match a company’s equipment, environment, or product rather than relying on generic stock footage.

Creative Localization

Reference consistency and local editing are important for producing variants across languages, climates, packaging versions, and audience segments. The goal is to modify the relevant creative elements without regenerating the entire campaign from scratch.

Production Notes

Build an Evaluation Set

I would start with evaluation rather than direct customer-facing automation. Include product ads, character scenes, motion-heavy prompts, brand-safe requests, rejected prompts, and edge cases.

Score at least:

Prompt adherence
Identity and reference consistency
Motion quality
Visual artifacts
Audio quality
Moderation behavior
Latency
Cost
Failure and retry rates

Keep Generation Asynchronous

A 30-second video can take substantially longer than a chat completion or image request. Use a queue, persist task IDs, poll status, and notify users when the signed output is ready. This avoids request timeouts and makes retries explicit.

Version Everything

Store the prompt, model ID, parameters, reference IDs, output URL, reviewer score, and final decision. Prompt and output versioning makes comparisons between Seedance 2.5, Seedance 2.0, Veo, Kling, Runway, and other models reproducible.

Retain Human Review

Commercial video introduces brand, legal, likeness, and copyright concerns. Human review is appropriate for public advertising, realistic people, influencer-like content, regulated industries, and outputs using third-party references.

Avoid requests involving copyrighted characters, real people without permission, or misleading depictions.

Design Fallbacks

Do not assume one model should serve every workload. Short drafts may be better handled by Seedance 2.0 or a faster video model, while Seedance 2.5 can be reserved for final, high-value generations. Availability, latency, and cost should all be part of routing decisions.

Frequently Asked Questions

Is Seedance 2.5 available?

As of June 30, 2026, it was reportedly in global enterprise beta, with public availability expected in early July 2026. Developers should check the live model catalog before using it in production.

How long can it generate?

The headline capability is native video generation up to 30 seconds. Seedance 2.0’s documented generation range is 4-15 seconds, so the newer model substantially increases single-pass duration.

What is the main difference from Seedance 2.0?

Seedance 2.5 adds native 30-second generation, up to 50 multimodal references, and improved local editing control. Seedance 2.0 already provides text, image, audio, and video inputs, native audio-video generation, and strong motion stability.

What is it best suited for?

The strongest target workloads are 30-second social ads, product videos, cinematic storyboards, previsualization, brand-consistent creative variants, e-commerce demonstrations, training clips, and other reference-heavy generation tasks.

What should developers verify before production?

Confirm the live model ID, access status, pricing, exact resolution and duration limits, output formats, generation latency, failure behavior, moderation rules, and signed URL lifetime. These details may change as the model moves from beta to public release.

Originally published at cometapi.com

Calling Claude Through a Gateway: SDK Choices and Production Trade-offs

Mason Reed — Mon, 21 Sep 2026 02:39:29 +0000

I reach for a unified gateway when an application needs several model providers but does not need several separate account, billing, and SDK integrations. It is also a way to call Claude without maintaining a direct Anthropic developer account: the application authenticates with the gateway, which routes requests upstream.

CometAPI is one example, advertising Claude, GPT, and 500+ other generative AI models behind a single key and an OpenAI-compatible endpoint. Its mid-2026 model listings include Claude Opus 4.8 and Claude Sonnet 5. Those are catalog claims, so I would confirm current availability before choosing a production model.

The important decision is not just which provider handles billing. It is whether the application needs a portable chat interface or Claude-specific request semantics.

Choose the API Contract First

The gateway exposes two integration paths:

Concern	OpenAI-compatible API	Native Anthropic Messages API
Endpoint	`/v1/chat/completions`	`/v1/messages`
SDK base URL	`https://api.cometapi.com/v1`	`https://api.cometapi.com`
Model scope	Multiple providers, including GPT, Claude, and Gemini	Claude
Authentication	Bearer	`x-api-key` or Bearer
Response structure	`choices` and `message`	Content blocks
Claude-specific controls	Not exposed through this compatibility path	Thinking, caching, effort, server-side tools

I would use chat completions for shared application code across providers. I would choose Messages when extended thinking, prompt caching, or server-side tools are part of the actual workflow. A common interface is useful, but it is not a promise that every model has identical capabilities.

Reuse an OpenAI Client

Install the SDK with pip install openai. Generate a gateway key, then change the client’s base_url and api_key. This request retains the source example’s model, temperature, and output limit:

from openai import OpenAI

client = OpenAI(base_url="https://api.cometapi.com/v1", api_key="your_gateway_key")
response = client.chat.completions.create(
    model="claude-opus-4.8",
    messages=[{"role": "user", "content": "What are the primary structural benefits of a unified API gateway?"}],
    temperature=0.7, max_tokens=1024,
)
print(response.choices[0].message.content)

For streaming, the gateway translates Claude’s native server-sent events into OpenAI-compatible chunks. Using the same client:

stream = client.chat.completions.create(
    model="claude-opus-4.8",
    messages=[{"role": "user", "content": "Explain the concept of latency overhead in unified APIs."}],
    temperature=0.7, max_tokens=1024, stream=True,
)
for chunk in stream:
    if chunk.choices:
        content = chunk.choices[0].delta.content
        if content:
            print(content, end="", flush=True)

Changing model lets this integration address another supported model without replacing the client or streaming loop. I would still test parameter support, tool behavior, structured output, and error handling for each target. Request compatibility reduces integration work; it does not eliminate model-specific validation.

Keep Claude-Specific Features on the Messages Path

The native route uses the official Anthropic SDK, but the key comes from the gateway. Set COMETAPI_KEY in the environment before running this example. Notice that the base URL does not include /v1:

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.cometapi.com", api_key=os.environ["COMETAPI_KEY"],
)
message = client.messages.create(
    model="claude-sonnet-4-6", max_tokens=1024,
    system="You are a helpful assistant.",
    messages=[{"role": "user", "content": "Hello, world"}],
)
print(message.content[0].text)

The SDK sends x-api-key by default; the endpoint also accepts Authorization: Bearer. The documented Claude-specific controls include thinking with a minimum budget_tokens of 1,024, cache_control on content blocks, output_config.effort, and server-side web_fetch and web_search tools. Check support against the selected model rather than assuming every Claude version accepts every control. The native example uses claude-sonnet-4-6, not the Sonnet 5 model mentioned in the catalog.

What I Would Verify Before Shipping

Latency and Compatibility

Every gateway introduces another network hop plus authentication, routing, and potentially schema translation. The source reports typical overhead below 400 ms; I would treat that as a claim to benchmark, not a latency guarantee. Background summarization can tolerate a different budget from real-time voice or tightly timed agent workflows. Streaming does not remove the need to measure initial response latency.

System prompts, temperature, structured JSON output, and tool/function calling are described as supported through the compatibility layer. Newly released or proprietary features may arrive later. For a workflow that depends on a particular feature, I would check the compatibility documentation and test the exact request. The native endpoint avoids some translation constraints, but its availability still needs verification.

Data Handling and Access

The gateway describes encrypted transit, including TLS 1.3, minimized persistent logging, and enterprise zero data retention configurations. “Minimized logging” is not the same commitment as ZDR. I would review retention, zero-data-training policies, logging configuration, and contractual scope before sending sensitive inputs.

Inference still happens at the upstream provider. Both the gateway’s handling and the model host’s data processing agreements matter. Likewise, using a gateway does not automatically remove regional compliance obligations, payment restrictions, or upstream access rules. A single account may simplify access, but it is not a universal compliance exemption.

Quotas, Cost, and Governance

Consolidated billing is the clearest operational benefit: fewer prepaid balances, invoices, credentials, and usage dashboards to maintain. Gateway quotas can simplify capacity management, but I would verify actual limits and throttling behavior rather than assume there is no upstream constraint or production approval process.

The source advertises pay-as-you-go pricing with no monthly fee, rates 20–40% below official pricing, and 1 million free signup tokens. These are commercial terms to confirm during evaluation, not architectural guarantees. Compare the price of the actual models and features the workload uses.

A shared interface also makes task-based routing easier. I would reserve a flagship model such as Claude Opus 4.8 for complex reasoning or long-context analysis, then evaluate cheaper models for classification, extraction, and formatting. Switching a model identifier is easy; proving acceptable output quality is the work.

The documented dashboard supports usage monitoring, project spending limits, access-token management, and budgets assigned to individual API keys. Those controls are worth testing: centralized billing only helps governance if an experimental project cannot consume the organization’s entire allocation.

My Decision Rule

I would choose a gateway when multi-model routing, A/B testing, consolidated procurement, and reduced SDK maintenance justify another dependency in the request path. I would use the OpenAI-compatible endpoint for portable chat workflows and the native Messages endpoint for Claude-specific behavior.

Before rollout, I would validate model availability, feature support, latency, quotas, current pricing, and both layers of data handling. Avoiding a direct Anthropic account simplifies administration. It does not remove the engineering responsibility to understand where requests go and what contract the application relies on.

Originally published at cometapi.com

GPT-6 Astra Access: Verify the Route, Then Make One Small Call

Mason Reed — Mon, 21 Sep 2026 01:53:33 +0000

I treat API access as three separate checks: the gateway lists the model, the credential works, and an authenticated request completes. Creating a key only covers part of that.

For a unified multi-model API such as CometAPI, the credential must belong to the gateway receiving the request. An OpenAI SDK client can target that gateway, but it still needs the gateway’s key and base URL.

Here’s the sequence I’d use to verify gpt-6-astra access before wiring it into an application.

Check the model catalog first

The source guide reported gpt-6-astra as available, with upcoming: false and support for both /v1/responses and /v1/chat/completions. Treat that as a dated observation: check the live catalog before integration.

The public catalog endpoint requires no Authorization header:

curl -fsSL https://api.cometapi.com/api/models \
  | jq '.data[] | select(.id == "gpt-6-astra") | {
      id,
      provider,
      upcoming,
      endpoints
    }'

Look for the exact ID, upcoming set to false, and the route you intend to use in endpoints. That establishes public routing availability; it does not validate your account or key.

If the command prints nothing, check the spelling and the live model page. Don’t substitute a display name, prepend a provider name, or borrow an alias from another gateway.

I’d start with /v1/responses for the reasoning workflow described here. Use /v1/chat/completions when the application specifically needs the messages-based interface.

Create a credential with a limited quota

Create an account, sign in, and open the API Keys page. Select Create API Key, name it something recognizable such as astra-dev, choose an appropriate quota, and copy the value.

You also need sufficient account credit or quota and a server-side environment for storing the credential. For a local Bash session:

read -rsp "Gateway API key: " COMETAPI_KEY
printf '\n'
export COMETAPI_KEY

Keep development, staging, and production keys separate. Explicit quotas limit the damage from accidental loops or leaked credentials, while descriptive names make rotation easier.

Store deployed credentials in a secrets manager or server-side environment variable. Keep them out of browser JavaScript, mobile bundles, repositories, screenshots, and support tickets. Store any direct OpenAI credentials separately so configuration changes cannot silently mix providers.

Make the smallest useful request

My first request would contain no tools, files, streaming, or long context. A small payload makes authentication and routing failures easier to isolate.

Send the gateway key to the gateway endpoint:

curl --fail-with-body \
  https://api.cometapi.com/v1/responses \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Reply with exactly: GPT-6 Astra access confirmed.",
    "reasoning": {"effort": "low"},
    "max_output_tokens": 40
  }'

The target is HTTP 200 with a response object containing an id, a completed status, the expected model, output content, and usage data. Keep the response ID during testing; it helps investigate routing or platform problems.

An HTML page or redirect does not establish API access. Check the hostname and path before changing the payload.

Use the same configuration in Python

The OpenAI Python SDK can make the same request with an explicit api_key, base_url, and model selection. A separate gateway SDK is unnecessary.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Reply with exactly: GPT-6 Astra access confirmed.",
    reasoning={"effort": "low"},
    max_output_tokens=40,
)

print(response.id)
print(response.status)
print(response.output_text)

Use https://api.cometapi.com/v1 as the SDK base URL and https://api.cometapi.com/v1/responses for the direct request. Neither URL has a trailing period. Don’t substitute api.openai.com while retaining the gateway credential.

Once the minimal call succeeds, add application instructions and features individually.

Decide what counts as a successful access test

I’d keep four checks in the integration notes:

Check	What it establishes
Catalog returns `gpt-6-astra`	The public catalog recognizes the model and lists its routes.
Authenticated endpoint returns JSON	The request reaches an API endpoint rather than a login page or redirect.
Response completes with the expected model	The key, account, route, payload, and model routing worked together for that request.
Usage appears in the dashboard	The request is recorded against the intended account.

A successful catalog lookup cannot prove private access. Likewise, a key’s existence cannot guarantee sufficient quota, current availability, a valid payload, or acceptance under rate limits.

Check usage or billing records after the first call. This also gives you a starting point for cost monitoring.

Diagnose failures before retrying

Authentication and access: 401 or 403

For 401 Unauthorized, check for a missing, malformed, or expired key and verify the destination host. The header should be exactly:

Authorization: Bearer $COMETAPI_KEY

Reload the environment variable or rotate the credential if needed. Repeating the same invalid credential will not help.

For 403 Forbidden, return to the minimal payload, remove optional fields, and check account status, quota, and model access. Treat it as an access or request problem before assuming a temporary outage.

Routing: HTML, redirects, or model-not-found errors

Recheck the base URL and endpoint path. During debugging, avoid silently following redirects on the authenticated request: a wrong path can otherwise appear to be a successful connection.

For a model-not-found response, query the catalog again and compare the exact gpt-6-astra identifier.

Rate limits and server failures

For 429 Too Many Requests, inspect the error body and account limits. Reduce burst concurrency and use exponential backoff with jitter for rate-limit retries. Monitor usage by model and route.

For 500, 503, 504, or 524, retain any request or response ID and use bounded backoff for temporary platform or timeout failures. Inspect the body first: if it reports invalid_request, fix the payload before retrying.

Put production controls around the working call

After access is confirmed, issue a production-specific key with the smallest practical quota. Store it in a secrets manager, restrict who can view or rotate it, and document rotation.

Keep model calls on your server. Browser and mobile clients should call your authenticated backend, where you can enforce user permissions, rate limits, and spending controls.

Log the route, model ID, HTTP status, latency, response ID, and token usage. Redact credentials and sensitive prompt data. Track development and production separately so test traffic does not obscure production failures.

For payload changes, consult the Responses API documentation. The source also links a first-party model reference; check current documentation and the live catalog before relying on a capability or endpoint.

Originally published at cometapi.com

GPT-5.6 API Costs: What I’d Budget Beyond the Token Price

Mason Reed — Fri, 18 Sep 2026 17:10:24 +0000

Start with the route, not the family name

The first thing I’d check in a GPT-5.6 integration is the model ID. According to OpenAI’s model guidance, gpt-5.6 routes to gpt-5.6-sol. It does not automatically select the cheapest tier that can handle a request.

If I want Terra or Luna pricing, I’d use gpt-5.6-terra or gpt-5.6-luna explicitly.

The July 30, 2026 pricing update reduced Terra rates by 20% and Luna rates by 80%, while leaving Sol unchanged. Here are the updated Standard rates for requests with at most 272,000 input tokens.

All token prices below are USD per 1 million tokens.

Model	Input	Cached input	Cache write	Output
`gpt-5.6-sol`	$5.00	$0.50	$6.25	$30.00
`gpt-5.6-terra`	$2.00	$0.20	$2.50	$12.00
`gpt-5.6-luna`	$0.20	$0.02	$0.25	$1.20

Source: OpenAI API pricing.

OpenAI positions Sol as the flagship, Terra as the balanced option, and Luna as the low-cost tier for high-volume work. I’d treat those descriptions as evaluation starting points, not routing rules.

The number that matters most for ordinary short-context traffic: output costs 6× as much as uncached input across all three tiers. Trimming unnecessary response text can matter more than shaving a few tokens off a system prompt.

Put the rates through an actual workload

A rate table is useful, but I prefer turning it into request costs immediately. The examples here use the updated July rates consistently, without caching, tools, retries, or regional adjustments.

A 1,000-input, 500-output request

For Sol:

Input:  1,000 / 1,000,000 × $5  = $0.005
Output:   500 / 1,000,000 × $30 = $0.015
Total:                           $0.020

Applying the same request shape to each model:

Model	Input cost	Output cost	Total per request
Sol	$0.005	$0.015	$0.020
Terra	$0.002	$0.006	$0.008
Luna	$0.0002	$0.0006	$0.0008

Output accounts for 75% of the token bill even though the request contains twice as many input tokens as output tokens.

For chat, code generation, and agents, I’d look for unnecessary verbosity before spending much time optimizing a small prompt.

One million requests per month

Now change the workload to:

1 million requests per month
2,000 input tokens per request
500 output tokens per request

That produces 2 billion input tokens and 500 million output tokens monthly.

Model	Monthly input	Monthly output	Monthly total
Sol	$10,000	$15,000	$25,000
Terra	$4,000	$6,000	$10,000
Luna	$400	$600	$1,000

For this workload, the price cuts move Terra from $12,500 to $10,000 and Luna from $5,000 to $1,000.

Those differences justify routing experiments. They do not prove that Luna is the cheapest way to complete the work. More retries, failed tool calls, or manual review can consume the apparent savings.

My preferred metric is:

Cost per successful task = total workflow cost / successful tasks

I’d track human review alongside that metric, rather than pretending it disappears because it is absent from the API invoice.

Treat 272K input tokens as a billing boundary

GPT-5.6 supports a 1.05M-token context window, but context capacity and short-context pricing are different limits.

When input exceeds 272,000 tokens, the higher rates apply to the entire request, not just the excess tokens:

Input: 2×
Cached input: 2×
Cache writes: 2×
Output: 1.5×

Model	Long input	Long cached input	Long cache write	Long output
Sol	$10.00	$1.00	$12.50	$45.00
Terra	$4.00	$0.40	$5.00	$18.00
Luna	$0.40	$0.04	$0.50	$1.80

This is a pricing cliff, not a gradual overage charge. It also means the 6× output-to-input ratio applies to short-context Standard pricing; long-context pricing has a different ratio because the multipliers differ.

Near the boundary, I’d inspect:

Duplicate retrieval chunks
Stale conversation history
Repository files unrelated to the task
Tool output that could be reduced before the next model call

That cleanup can do more than reduce token count: it can keep the whole request in the lower pricing band. OpenAI’s cost optimization guide covers additional approaches.

Choose a processing tier separately from the model

Model selection is only one pricing decision. Eligible GPT-5.6 text workloads also have different processing options.

These are short-context input/output rates per 1 million tokens:

Processing option	Sol	Terra	Luna	Where I’d consider it
Standard	$5 / $30	$2 / $12	$0.20 / $1.20	Normal synchronous traffic
Batch	$2.50 / $15	$1 / $6	$0.10 / $0.60	Offline asynchronous jobs
Flex	$2.50 / $15	$1 / $6	$0.10 / $0.60	Work that tolerates slower processing
Fast mode	$10 / $60	$4 / $24	$0.40 / $2.40	Latency-sensitive traffic

The listed Batch and Flex rates are 50% below Standard. I’d check their operational constraints before moving any production workload, rather than treating them as interchangeable discounts.

Priority Processing was renamed Fast mode on July 30, 2026. Existing requests using service_tier: "priority" remain compatible.

For Sol, Fast mode offers up to 2.5× faster processing at 2× the Standard token price, without changing model intelligence. That is a latency trade-off, not a quality upgrade. I’d pay for it only where the user-facing benefit justifies the premium.

Cache reuse, not merely long prompts

Cache writes cost 1.25× normal input, while matching cached reads use the discounted cached-input rate.

For a reusable 100,000-token prefix on short-context Sol:

Operation	Prefix input cost
One uncached use	$0.50
One cache write	$0.625, approximately $0.63
One matching cached read	$0.05

Two uncached uses cost $1.00. A cache write followed by one matching read costs $0.675, saving $0.325.

That comparison covers only the reusable prefix. It excludes output, other uncached input, tools, and retries.

The practical distinction is between a long prefix and a long, stable, reused prefix. A write that never gets reused costs more than ordinary input processing.

I’d measure actual cache hits and read the prompt caching documentation for matching requirements, explicit breakpoints, and TTL behavior before building savings into a forecast.

Budget for tokens you don’t see and calls outside the model

Reasoning is billed output

Reasoning tokens are charged as output tokens even when they do not appear in the visible response. A concise answer does not necessarily imply a small output-token bill.

Where supported, reasoning.mode = "pro" is a setting I’d benchmark rather than enable by default. OpenAI does not list a separate fixed Pro surcharge; its cost impact comes from resulting token usage.

The comparison should include task success, total output tokens, latency, and retries—not just whether one response looks better.

Search has its own bill

Standard web search is listed at $10 per 1,000 calls, plus search-content tokens billed at the selected model rate.

At that price, two searches can cost more than the model tokens for a small Luna request.

There is also a separate web search preview rate for non-reasoning models: $25 per 1,000 calls, with search-content tokens free. I would not apply one search rate across every tool and endpoint. Check the exact combination on the pricing page.

Residency can add an uplift

Eligible regional processing or data-residency endpoints for models released on or after March 5, 2026 carry a 10% uplift.

If residency is a requirement, that belongs in the initial estimate—not in an explanation for why the first invoice exceeded it.

Keep the older models in the comparison

A new family does not make previous routes irrelevant. These are the listed Standard short-context rates for several other OpenAI text models:

Model	Input	Cached input	Output
`gpt-5.5`	$5.00	$0.50	$30.00
`gpt-5.4`	$2.50	$0.25	$15.00
`gpt-5.4-mini`	$0.75	$0.075	$4.50
`gpt-5.4-nano`	$0.20	$0.02	$1.25

Luna now matches GPT-5.4 nano’s $0.20 input rate, with slightly cheaper output: $1.20 versus $1.25.

That is a useful pricing comparison, not evidence that the models behave identically. I’d keep existing routes in the evaluation set until the replacement earns its place.

Also, ChatGPT subscriptions and API billing are separate products. “ChatGPT API pricing” does not identify a rate; the model and usage type do.

My production cost checklist

For a basic uncached request, the arithmetic is:

Token cost =
    (input tokens / 1,000,000 × input rate)
  + (output tokens / 1,000,000 × output rate)

For production, I’d expand that into a workflow estimate covering uncached input, cached reads, cache writes, output and reasoning tokens, tool fees, applicable processing-tier rates, regional uplift, retries, and fallbacks.

Then I’d run the same representative tasks through candidate routes:

Use explicit model IDs. Avoid paying Sol rates accidentally through gpt-5.6.
Start with the cheapest plausible model. Promote difficult tasks based on measured results.
Record billed output, not just visible text. Include reasoning usage.
Monitor the 272K boundary. Aggregate averages can hide expensive individual requests.
Test Batch or Flex for non-urgent work. Verify operational fit.
Measure cache reuse, tool calls, and retries. Do not assume their costs cancel out.
Compare cost per successful task against latency and reliability.

For cross-provider evaluations, a unified API such as CometAPI can be useful for running the same workload through multiple OpenAI-compatible routes.

The cheapest token rate is a starting hypothesis. The route I’d ship is the one that meets the quality and latency requirements at the lowest measured workflow cost.

Originally published at cometapi.com

Stop Reconstructing Client AI Spend From Logs

Mason Reed — Fri, 18 Sep 2026 16:53:33 +0000

At the end of a billing period, I want to answer a simple question: how much did each client’s AI work cost?

Most provider dashboards answer a different question: how much did the account spend in total? That number is useful, but it doesn’t tell me how to divide the bill across clients.

The usual workaround is unpleasant. I export request logs, match timestamps to projects, estimate ambiguous records, and maintain a spreadsheet until the numbers look plausible. That process is slow, difficult to audit, and not something I want to use as the basis for an invoice.

The underlying issue is structural: provider billing is organized around my account, while my business is organized around clients.

Use API keys as cost centres

The clean fix is to issue a separate API key for each client—or for each client workflow—and track usage independently per key.

Every request already carries the identity of the key that made it. If each key maps to one client, attribution happens when the request runs instead of during month-end reconciliation. Cost per client becomes a dashboard value rather than something I have to reconstruct from raw records.

This is essentially a cost-centre model:

One client or workflow gets one clearly named key.
Requests made with that key accumulate in its usage bucket.
The bucket reports the client’s spend and activity.
The invoice is built from those totals.

This is particularly useful when multiple models are accessed through the same unified endpoint. I can keep all client keys and their usage in one account while still getting separate reporting. A unified multi-model API such as CometAPI is relevant here because the alternative is consolidating usage across several provider accounts.

The data available per key

A useful per-key report should expose the dimensions needed to support an invoice:

Total spend: the dollar cost of requests made with the key during the billing period.
Request volume: the number of calls, which helps validate activity.
Token usage: input and output token counts behind the charge.
Model breakdown: the models used and the cost associated with each.

That gives me more than a single number. If a client’s workload uses an inexpensive model for bulk processing and a frontier model for difficult tasks, the model split explains the resulting total. If a client questions the bill, I can provide usage and token context rather than presenting an unexplained portion of a larger account charge.

Why this is better than the usual workarounds

Approach	Operating model	Failure mode
Single key, parsed logs	One key serves every client; usage is reconstructed at invoice time.	Slow, error-prone, and approximate whenever records are ambiguous.
Separate provider accounts	Each client gets separate accounts with each provider.	Credentials, dashboards, and invoices multiply quickly.
Manual spreadsheet tracking	Usage is recorded by hand as work happens.	It depends on sustained discipline, becomes stale, and compounds errors.
Per-key tracking	Each client gets a key on one account; usage is metered automatically.	Attribution is captured at request time and reported directly.

The important difference is when attribution occurs. The first three options push the work to invoice time. Per-key tracking captures the relationship between request and client at the source.

For two clients, manually parsing logs may be tolerable. For fifteen, it becomes recurring operational work. With fifty clients, it is effectively a part-time job. Per-key tracking requires roughly the same setup pattern at each scale: issue a key, use it consistently, and read the resulting totals.

A setup pattern that holds up

1. Choose the reporting boundary

Start with one key per client unless the client needs separate billing streams. If a client has multiple projects or workflows that should be reported independently, use one key per client-project or per workflow.

Finer-grained keys produce finer-grained reports, but they also increase the number of credentials to manage. I use the smallest number of keys that matches the invoice structure I actually need.

2. Name keys for humans

A dashboard full of opaque key IDs is not a reporting system. Name keys with the client or project they represent so the usage list is immediately readable.

This matters at invoice time: the report should look like a client list, not like a collection of tokens that needs another mapping table.

3. Configure each deployment with its own key

Point each client integration at the corresponding key. In most cases, this is an environment or deployment configuration change rather than an application rewrite.

The important operational rule is that a shared service must not accidentally use a default key for every client. The key selection needs to follow the same client or workflow boundary as the work being billed.

4. Read the totals at the billing boundary

At the end of the billing period, inspect each key’s:

Spend
Request count
Input and output tokens
Model usage and model-level cost

Those values form the per-client usage report. There is no need to infer ownership from timestamps or manually split an aggregate total.

5. Rotate keys independently

Per-client keys also reduce the blast radius of credential operations.

If a client leaves, revoke that client’s key. If one key is exposed, rotate that key without interrupting every other client. The control boundary and the billing boundary are the same, which is much safer than relying on one credential for the entire operation.

Usage is metered per token against the same published rates regardless of which key made the request. That means the per-key total maps directly to the underlying pricing: the amount charged to the client traces back to the amount charged by the platform, with any agency margin added transparently.

The operational benefits go beyond invoicing

Client-level profitability

Once I can see AI cost per client, I can compare it with the client’s fee. That exposes engagements with healthy margins and those quietly consuming them.

This is useful for repricing, changing the workflow, or deciding whether a particular service should be packaged differently.

Faster detection of runaway usage

A bad loop, misconfigured integration, or unexpected traffic surge is easier to spot when usage is attached to a client key. The increase is visible in the relevant bucket instead of being hidden inside the account aggregate.

Fewer billing disputes

A client asking what they paid for can receive an explanation based on request volume, token counts, and model usage. That is more defensible than assigning them an estimated share of a lump-sum provider bill.

Better estimates for future work

Historical per-client usage gives me real data for quoting similar projects. Instead of guessing how much model usage a new engagement might require, I can use comparable workflows and their actual costs.

At larger agencies, the same account-level controls—team access, spending visibility, and administrative oversight—turn this from a billing convenience into an operational control. Per-key attribution is useful on its own, but it becomes more valuable when it is part of the broader account governance model.

The practical pattern

Provider dashboards generally make total account spend easy to see. They do not automatically know which client should receive each portion of that total.

The solution is to make client identity part of the request path:

Issue one key per client or billable workflow.
Give each key a clear name.
Configure the matching integration to use it.
Review per-key usage at the invoice boundary.
Revoke or rotate keys independently when necessary.

That changes month-end reconciliation from log analysis into reporting. It also creates a useful operating dataset for profitability, anomaly detection, client conversations, and future estimates.

The dashboard behavior and per-key workflow described here were checked against platform documentation in June 2026. Platform features evolve, so specific reporting and administrative capabilities should be confirmed against current documentation before making them part of a billing process.

Originally published at cometapi.com

Consolidating AI API Keys Is a Migration, Not an Endless Cleanup Task

Mason Reed — Thu, 17 Sep 2026 15:34:35 +0000

I would scope AI credential consolidation like any other migration: inventory the dependencies, prove one workload, move the rest, and retire the old path. “Reduce credential sprawl” is an indefinite backlog item. “Route these workloads through one endpoint and revoke these keys” has an acceptance test.

The distinction matters because multi-provider setups rarely come from a deliberate architecture decision. OpenAI serves the first feature, Claude gets added for another, Gemini covers a specific task, and image or audio experiments bring more accounts. Each addition makes sense locally. Together, they leave a collection of secrets, dashboards, invoices, and configuration that somebody has to maintain.

The useful question is not whether fewer keys would look tidier. It is whether a bounded migration can remove enough recurring work to justify another infrastructure dependency.

Define “Done” Before Picking a Gateway

My acceptance criteria would be explicit: every model currently required is reachable through the consolidated endpoint, every migrated workload passes its checks, the base URL and key live in environment variables, and obsolete provider credentials are revoked.

That makes consolidation a finishable project. It does not mean authentication, billing, or integration maintenance disappears forever. The migration can end; operating the resulting dependency still takes work.

The source’s estimate is a single sprint for most teams, sometimes a couple of focused days. I would treat that as a planning hypothesis until the inventory and first workload establish how much compatibility work is involved. Likewise, a claimed payback measured in weeks needs to be checked against actual maintenance costs, not assumed.

Operational concern	Separate provider integrations	Consolidated access
Credentials	A set for each provider	One key for covered workloads
Spend visibility	Multiple provider dashboards	A consolidated dashboard
Billing	Separate accounts and invoices	One billing relationship
Model changes	May require account and integration setup	Can be a model-name change for compatible calls
Migration completion	No consolidation target	Workloads moved and old keys retired

For this use case, a unified multi-model API such as CometAPI is relevant because it puts models from multiple providers behind a common access layer. The meaningful coverage number is not the catalog headline; it is how many models from your own inventory are actually supported.

Evaluate the Dependency Before Migrating

I would address concentration risk before scheduling the rollout. One endpoint and one credential reduce the number of independent configurations, but they also concentrate access behind a shared dependency. Fewer places to misconfigure authentication does not automatically mean lower overall operational risk.

OpenAI-compatible access helps make a migration reversible when the workload already uses compatible request and response formats. Moving back may be the same base-URL-and-key change in reverse. I would still verify that against the actual destination rather than treating “compatible” as a guarantee that every provider feature is interchangeable.

The trade-off depends on the workload. Several providers supporting a mix of features make consolidation more attractive. A single-provider, single-model workload at ultra-high volume may have less to gain from an intermediary.

That is the decision I want made deliberately: does the common access layer save more integration and operational effort than its dependency costs? Reversibility helps, but only when the return path has been checked.

Run the Migration in Five Steps

1. Inventory What Production Actually Calls

List every provider, active key, consuming workload, and model. Include environment-specific configuration and experiments that still have live credentials.

This is where forgotten accounts and lightly used integrations become visible. The inventory also prevents an incomplete migration from being declared finished because the main application moved while a background job still calls a provider directly.

2. Verify Coverage With the New Account

Create the consolidated account, generate the key, and confirm that every required model is accessible through it.

Do this before bulk configuration changes. A catalog entry is useful for discovery; your required calls are the migration scope. Any workload that cannot move needs an explicit exception, and that exception changes the claim that everything now runs through one key.

3. Prove One Low-Stakes Workload

Choose a workload with limited consequences if something fails. Change its base URL and key, then run real requests through the complete application path.

The goal is more than successful authentication. Confirm that the request works and that the response still satisfies the downstream code. This pilot establishes whether the remaining migration is configuration work or whether adapters need attention.

4. Move the Remaining Workloads

For integrations with unchanged request and response formats, repeat the proven base-URL-and-key change. Downstream code should not need modification merely because the endpoint changed.

Keep the endpoint and credential in environment variables so later routing changes remain configuration changes. Where a workload differs from the pilot, verify that difference instead of assuming the same pattern applies everywhere.

5. Retire the Old Access Paths

After every intended workload runs through the new endpoint, revoke obsolete provider keys and close accounts that are no longer needed.

This is part of the migration, not optional cleanup. Leaving the old credentials active preserves much of the secret-management burden you were trying to remove. The finish line includes retirement, not just successful traffic through the new service.

What I Would Expect to Improve

Credential-related incidents: Separate credentials create separate opportunities for expiration, misconfiguration, limits, and drift between environments. Consolidation reduces that configuration surface. The source reports fewer integration incidents among teams that consolidate, but provides no quantified incident data; I would measure the effect locally.

Model evaluation speed: For compatible models behind the same endpoint, switching can become a model-name configuration change rather than a new account and integration exercise. That removes setup friction from trying alternatives. It does not eliminate the need to evaluate their behavior.

Billing operations: One account can replace multiple invoices, payment arrangements, balances, and spend dashboards. The described pay-as-you-go offering has no minimum and credits that do not expire. Those are account-specific terms to verify, not properties inherent to every unified API.

Day-to-day context switching: One authentication pattern, documentation entry point, and dashboard reduce the need to remember which provider owns which operational detail. This is harder to quantify than invoice count, but it is a practical benefit when developers repeatedly move between workloads.

I would put the inventory on the next sprint’s backlog first, with the pilot immediately behind it. That produces enough evidence to scope the rest honestly. A consolidation migration is complete when its acceptance criteria pass, not when someone promises there will never be another credential task.

Originally published at cometapi.com

Seedance 2.5 Costs: Separate Token Pricing From Your Production Budget

Mason Reed — Thu, 17 Sep 2026 14:31:37 +0000

Two Billing Models, Two Different Estimates

I would not put Seedance 2.5 into a budget spreadsheet until I had picked the API route. The published BytePlus token prices and the gateway's per-second prices are different billing models, not interchangeable ways to quote the same request.

ByteDance Seed / BytePlus ModelArk lists the official model ID as dreamina-seedance-2-5-260628. Its published pricing is $10.70 per 1 million tokens without video input and $6.40 per 1 million tokens with video input. The published output tiers are 480p and 720p.

For five-second, 16:9 outputs, BytePlus gives these examples:

Input category	480p	720p
Without video input	$0.514	$1.156
With video input	$0.553–$2.152	$1.244–$4.838

The lower video-input token rate does not guarantee a cheaper request: input-video duration also contributes to estimated token consumption. BytePlus says it charges only for successfully generated videos. Published pricing and model information, however, do not by themselves confirm broad API access.

The per-second figures below come from the source's gateway pricing snapshots: August 27, 2026 for Seedance duration calculations and August 28, 2026 for the cross-model comparison. I would treat them as dated budgeting inputs, not a guarantee of current pricing or account access.

What I Would Verify Before Integrating

Seedance 2.5 is a multimodal video-generation model aimed at storytelling, reference-driven generation, and targeted editing. ByteDance describes support for up to 30 seconds of audio-video output in one pass, 30 image references, 10 video references, and 10 audio references, plus timestamp-level editing and multi-round extensions.

Those model capabilities should not be confused with the fields exposed by a particular API route. The documented gateway route uses seedance-2-5, supports text-to-video and image-to-video, and accepts durations from 4–30 seconds, defaulting to 5 seconds. Its listed output tiers are 480p and 720p; at 16:9, the exact sizes are 854x480 and 1280x720.

For unified multi-model access, CometAPI exposes Seedance 2.5, Vidu Q3, and Wan 3.0 through the same base URL and POST /v1/videos, allowing shared authentication, billing, queueing, polling, and monitoring. That is useful for comparisons and fallbacks, but I would still verify each route's sizes, duration limits, input fields, and callback support before shipping.

The asynchronous lifecycle matters as much as the submission endpoint: persist the returned id or task_id, poll GET /v1/videos/{id} until a documented terminal state, and download completed media promptly.

The Per-Second Budget

For the documented Seedance gateway rates, the calculation is straightforward:

generation_cost = requested_seconds * resolution_rate
effective_generation_cost_per_clip = total_generation_spend / accepted_clips

The first equation estimates an attempt. The second tells me whether the workflow is affordable. Neither automatically includes storage, delivery bandwidth, moderation review, editing, or reruns.

Requested duration	480p at $0.103/s	720p at $0.231/s
4 seconds	$0.41	$0.92
5 seconds	$0.52	$1.16
10 seconds	$1.03	$2.31
15 seconds	$1.55	$3.47
30 seconds	$3.09	$6.93

At these rates, 720p costs about 2.24 times as much as 480p for the same duration. I would use 480p for early composition, motion, and reference tests, then increase resolution once those decisions are stable. The listed route does not publish 1080p or 4K pricing; neither belongs in a budget until the live model directory and API schema support it.

Volume Changes the Rounding

Using the underlying rates rather than rounded per-clip display prices, 100 five-second generations cost $51.50 at 480p or $115.50 at 720p. For 1,000, the baseline is $515 or $1,155. These estimates assume every task completes once and every output is accepted.

Regenerating 10% of the 100-clip 720p batch raises generation spend to $127.05. Acceptance changes the result further: if only 70 of 100 outputs pass review, $115.50 ÷ 70 is approximately $1.65 per accepted clip, before review or editing costs. That is the number I would put beside a competing model's measured result.

Compare Routes at the Same Resolution

The comparison below uses the source's August 28, 2026 gateway snapshot. All listed rates are per generated second; five-second totals are rounded. “Not listed” means that exact resolution tier was not published for the route.

Resolution	Model ID	Rate per second	Five-second cost
480p	`wan3.0`	$0.05	$0.25
480p	`seedance-2-5`	$0.103	$0.52
480p	`viduq3`	Not listed	Not applicable
720p	`wan3.0`	$0.10	$0.50
720p	`viduq3`	$0.1232	$0.62
720p	`seedance-2-5`	$0.231	$1.16
1080p	`viduq3`	$0.1232	$0.62
1080p	`wan3.0`	$0.20	$1.00
1080p	`seedance-2-5`	Not listed	Not applicable

Wan 3.0 has the lowest listed native 480p and 720p rates in this comparison. Vidu Q3's lowest published tier is 540p at $0.056/s, or $0.28 for five seconds; I would not relabel that as a 480p offer. Its 720p tier includes synchronized audio, and its listed native 1080p rate is lower than Wan 3.0's.

Seedance is not the cheapest 720p option by unit price. Its longer duration and reference controls may justify the difference for particular shots, especially where they reduce stitching or reruns, but that needs testing against accepted output.

Where I Would Put Cost Controls

Recover existing tasks before retrying submissions. A polling timeout does not prove generation failed. The server may already have accepted the task, and resubmitting can create another billable job. Keep automatic retries bounded and retrieve the existing task whenever its ID is available.

Keep billing failures separate from quality failures. BytePlus's successful-generation billing statement is not a universal policy for every route. I would store task ID, model ID, requested seconds, size, terminal status, reported usage or charge, and rejection reason. An HTTP success is not evidence of a usable video; a terminal failure needs its own billing record.

Validate short drafts before committing to long output. My starting budget would use 480p at 4–5 seconds, promoting shots only after composition, motion, and reference handling pass review. A 30-second 720p attempt costs $6.93; repeating the whole clip because of an issue near the end gets expensive quickly. Higher resolution can also increase transfer, storage, review, and post-production costs without fixing an unstable prompt.

Benchmark the workflow, not just the rate card. For a fixed prompt set, I would record first-pass acceptance, rerun rate, generation time, and editing time. Cheaper routes can handle concept tests; Seedance can be reserved for validated shots that benefit from its capabilities. The decision metric is total API spend divided by accepted clips, with reviewer and editing costs added when material.

Originally published at cometapi.com

DEV Community: Mason Reed

Changing Gemini CLI Directories: Workspace, Project Settings, and Global Config

Start with the directory you actually want to change

Add another repository without moving configuration

Don’t rely on shell-mode cd to switch the session

Keep repository settings with the repository

Relocate global configuration only when necessary

Check environment-variable support for your release

Use a symlink or junction when native relocation is unavailable

Treat home-directory changes as an isolated-runtime option

Diagnose failures by scope

Keep API routing separate from directory configuration

Building an AI Companion: Persona, Memory, Tools, and the Tests That Matter

Choose the relationship before the stack

Decide how much infrastructure you want to own

Write a persona you can evaluate

Make memory a product feature with user controls

Specify boundaries alongside the personality

Ground answers before adding actions

Add voice and visuals once the text behavior holds up

Ship against a conversation test suite

Top 6 OpenClaw Skills you can't afford to miss in 2026

What Is OpenClaw and Why Skills Matter in 2026

Installation Basics (General for Most Skills):

1. GOG (Google Workspace Integration) — The Productivity Powerhouse

How to install:

Key Functions:

2. Agent Browser / Web Automation Skill — Autonomous Internet Agent

How to install:

Key Functions:

3. Self-Improving Agent / Capability Evolver — The Meta-Skill

How to install:

Key Functions:

4. GitHub Integration — Developer and Team Workflow Accelerator

How to install:

Key Functions:

5. Summarize Skill — Knowledge Distiller

How to install:

Key Functions:

6. Project Management Integrations (e.g., Linear, Notion) — Ops Orchestrator

How to install:

Key Functions:

How to choose the right OpenClaw skill

Comparison Table: Top 6 OpenClaw Skills

Advanced Tips, Security, and Scaling in 2026

Conclusion: Level Up Your OpenClaw Today

How to Add AI Video Generation to a SaaS App

What you'll build

Prerequisites:

Understand why video generation is different

Choose a model

Submit a Veo task

Poll for the result

Use Kling Video for more control

Animate a static image with Runway

Save the video before the URL expires

Handle failures

Node.js version

What's next

FAQ

Q: Why do I get a task ID instead of a video in the API response?

Q: How long does a generated video URL stay valid?

Q: What's the difference between Veo 3 Fast and Kling Video?

Q: Can I generate video from an image instead of a text prompt?

Q: Why does Runway return task_not_exist on the first poll?

Q: Why does Kling use "succeed" instead of "succeeded"?

Q: Is the synchronous polling loop safe to use in a web server?

The Hidden Cost of Juggling OpenAI, Anthropic, and Google Credentials

The cost most teams never count

5 hidden line items

1. Initial onboarding to each provider

2. Monthly billing reconciliation

3. Credential rotation and security hygiene

4. Debugging auth and integration errors across providers

5. Re-evaluating model choices each time a new release lands

Putting numbers on it

Why this cost never appears on the budget

The break-even calculation

The qualitative cost

The case to bring to your team

Don’t rely on shell-mode `cd` to switch the session

Q: Why does Runway return `task_not_exist` on the first poll?

Q: Why does Kling use `"succeed"` instead of `"succeeded"`?