# Arcads AI Video agent skills for Claude Code and Cursor

> Arcads AI Video packages Python workflows, agent instructions, and editor skills for generating marketing images and videos through Arcads. It suits Claude Code and Cursor users who want repeatable creative operations, but several pipelines depend on account access, external services, and extra local tools.

**krusemediallc/arcads-claude-code** — Arcads external API: agent skills, prompting library, and Cursor/Claude workspace

- Repository: https://github.com/krusemediallc/arcads-claude-code
- Stars: 1,665 · Forks: 405
- Language: Python
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/krusemediallc-arcads-claude-code

## What Arcads AI Video puts inside Claude Code and Cursor

This repository addresses creative production for advertising teams that want an AI coding agent to operate the Arcads external API. Its stated users are Claude Code and Cursor users working from a local workspace, with Python as the primary implementation language. The repository includes agent instructions, prompting material, shell and Python workflows, editor-specific skill directories, and a personal MASTER_CONTEXT.md workspace. That scope is narrower than an advertising management platform. According to the README, the project handles creative work such as generating images and videos, polling jobs, organizing outputs, and constructing prompts. It does not itself provide media buying strategy, campaign scaling, ROAS reporting, or automated ad delivery.

The supported creative surface is broad. The README names Seedance 2.0, Sora 2, Veo 3.1, Kling 3.0, Grok Video, several Nano Banana and ChatGPT image variants, OmniHuman, and audio-driven generation. It also describes a 37-template static Meta image-ad library and pipelines for Pixar-style and claymation ads. Those are external model and service capabilities reached through Arcads. The repository's distinct contribution is the agent layer: prompts, sequencing, status handling, files, and editor integration rather than the generation models themselves.

There is also a separate competitive research workflow. Its documented purpose is to collect image advertisements through Meta's Ad Library API, retrieve API-provided snapshots with authorized automated headless Chrome, review each image, and send the selected records to Airtable. This expands the repository beyond asset generation, but it does not make the repository an ad-spending system. The README explicitly says that the workflow writes recreation prompts and does not generate replacement advertisements.

## How Arcads authentication and agent jobs are organized

The basic workflows communicate with an Arcads external API using credentials stored in a local.env file. The.env.example recommends ARCADS_BASIC_AUTH as a pre-encoded HTTP Basic authorization header because it avoids encoding problems with special characters. It also documents ARCADS_API_KEY as an alternative, while warning that this method can produce a 403 response for some accounts. Optional connection fields include ARCADS_CLIENT_ID and ARCADS_BASE_URL, whose example value is https://external-api.arcads.ai.

The agent is expected to manage more than a single request. The README says it handles API calls, job polling, prompt engineering, file organization, and cost confirmation. That division matters for asynchronous media generation: a workflow can submit work, wait for processing, and place completed output in the workspace, although the README excerpt ends before showing a complete first generation command. It would be misleading to invent the missing request format. The repository's skill documentation and scripts are the proper source for model-specific calls.

Claude Code sees project behavior through.claude/ and related instruction files. Cursor receives the same skill set under.cursor/skills/. The top-level AGENTS.md, CLAUDE.md, and MASTER_CONTEXT.template.md indicate that the repository relies on editor-readable operating context, not just a conventional Python package. The setup script is expected to create a personal MASTER_CONTEXT.md after configuring credentials. This architecture favors agents that can read repository instructions and execute shell or Python workflows. It is less suitable for someone who wants a standalone GUI or expects the code to run without an agent.

## Claude Code and Cursor installation and first setup

The documented starting point requires Python 3.10+, an Arcads account, and an Arcads API key. Basic Arcads image generation, video generation, and polling workflows use Python, while several auxiliary image-ad generators are described as standard-library-only. Clone the repository and change into its directory with these commands:

```bash
git clone https://github.com/krusemediallc/arcads-claude-code.git
cd arcads-claude-code
```

Run the repository's setup script next:

```bash
./scripts/setup.sh
```

The README says this script links to account registration, asks for the Arcads API key, stores it in.env, verifies the Arcads connection, and creates a personal MASTER_CONTEXT.md. A real user should expect the prompt for credentials and a successful connection check before opening the directory in an editor. The file.env is excluded from version control according to the repository's configuration guidance.

For an existing configuration,.env.example shows the expected format. Replace the placeholder with the header obtained from the Arcads dashboard rather than guessing an encoding scheme:

```bash
ARCADS_BASIC_AUTH='Basic your_base64_encoded_credentials_here'
```

Open the cloned folder in Claude Code or Cursor after setup. Claude Code uses the repository's SessionStart hook to print an orientation banner, while Cursor exposes skills through.cursor/skills/. The first concrete creative request can then be expressed through the installed skill, but the README excerpt does not provide a complete command for submitting a generation job. It would be unsafe to claim that cloning and setup alone create an image or video.

## Optional dependencies for video, captions, publishing, and Meta extraction

The base install is intentionally lighter than the full workflow set. ffmpeg is required for Pixar-style, claymation, and caption-video assembly, including stitching and chroma-key overlays. Several shell scripts use jq. Caption transcription requires the whisper package, while caption burn-in invokes Node.js and npx hyperframes on demand. The macOS commands documented by the README are:

```bash
brew install ffmpeg
brew install jq
brew install node
pip install openai-whisper
```

These commands are not a blanket requirement for every Arcads action. Install only the tools associated with the workflow being invoked. Publishing through shared/skills/meta-ad-builder/scripts/requirements.txt adds a separate Python dependency set and Meta Marketing API configuration. The .env.example includes META_ACCESS_TOKEN, META_AD_ACCOUNT_ID, META_PAGE_ID, META_IG_USER_ID, META_PIXEL_ID, and META_API_VERSION. It states that ads created by the skill are PAUSED and that the token needs the ads_management scope.

The Meta Ad Library importer has different requirements: Chrome, Selenium, Pillow, Meta Ad Library API access, and either an Airtable personal access token or a connected Airtable MCP service. Its documented setup supports up to 10 advertiser or brand entries and a default limit of 100 active image ads per entry, subject to what Meta's API returns. API coverage varies by delivery country and access, and the described setup uses explicit UK/EU countries. The README also requires authorization for automated headless extraction. Reviewing each creative before import is part of the stated workflow, so this is not an unattended scraper with no human checkpoint.

## Where the repository fails or becomes the wrong tool

The largest dependency is external access. A successful local setup does not guarantee that every listed model, country, template, or API operation is available to a particular Arcads account. Authentication can also differ by account. The project documentation says an API key is sent as an HTTP Basic username with an empty password, but some accounts may receive 403 responses and should use the pre-encoded header instead. Any team evaluating this repository should therefore verify model availability and authentication before automating a production campaign.

The repository is also unsuitable for users seeking local model inference. The creative stack depends on remote Arcads services and named external generation platforms. Offline operation is not claimed, and no local checkpoint or alternative provider is documented. There is no release series published on GitHub, so installation follows the repository branch rather than a versioned package. The MIT license permits use and modification under its terms, but that does not grant access to Arcads, Meta, Airtable, or any other paid or gated service.

Operational boundaries are equally important. The Meta importer generates descriptive recreation prompts, not finished replacement ads. The creative workflow does not replace campaign measurement, compliance review, media buying, or budget controls. Shell scripts assume bash, and the README recommends WSL2 for Windows users. Teams needing a deterministic Python library, a desktop application, or a documented REST client should inspect the scripts before assuming that this editor-oriented skill pack matches their interface requirements.

## Arcads skill pack versus a direct Arcads API integration

A direct Arcads API integration is the clearest alternative. The Arcads skill pack adds prompting conventions, agent instructions, job polling, workspace organization, editor hooks, and multi-step creative workflows. A direct integration would begin with Arcads HTTP authentication and expose only the API operations the application explicitly implements. It can produce a smaller dependency surface and a more predictable user interface because the surrounding agent is removed.

The tradeoff runs in the opposite direction for creative experimentation. This repository already groups model selection, prompt construction, output handling, templates, and optional local processing into an AI-assisted workspace. Its value is not that it exposes a novel Arcads protocol. It is that Claude Code or Cursor can interpret the repository and carry out a broader creative procedure. A direct API client is better when software control, strict transaction boundaries, or predictable application behavior matter more than agent flexibility. The Arcads skill pack is better when the operator wants filesystem-oriented creative operations and is comfortable supervising an AI agent.

Maintenance also differs. The repository was not archived, and its last push was on 2026-09-22. That is recent activity, but it is not evidence of API compatibility or production stability. There are no GitHub releases, so users receive no published release cadence from the repository. Local dependencies are selective, which lowers the cost for basic workflows but raises the number of configurations an operator may encounter. Pinning or recording the repository revision used for a campaign is therefore more concrete than waiting for a nonexistent release version.

## Conclusion

Adopt this repository if you already have an Arcads account, work in Claude Code or Cursor, and want a documented collection of image, video, and ad research workflows. Do not adopt it as a standalone creative suite, an automated media buying system, or a replacement for Meta API access and local media tooling. Verify account access, the exact generation command for your selected model, authentication in .env, and the availability of every external service before committing an advertising workflow to it.

## FAQ

### What is krusemediallc/arcads-claude-code used for?

It is an agent skill pack for creating AI marketing videos and images through Arcads from Claude Code or Cursor. It also includes optional workflows for Meta research, Airtable import, captions, and Meta ad publishing.

### What does krusemediallc/arcads-claude-code require to get started?

The basic Arcads workflows require Python 3.10+, an Arcads account, and an API key. Optional pipelines require tools such as ffmpeg, jq, Node.js, npx hyperframes, whisper, or Chrome and Selenium.

### Does krusemediallc/arcads-claude-code include GitHub releases?

No. The repository has no GitHub releases, and the README directs users to clone the repository and run ./scripts/setup.sh.

## Sources

- [Issues](https://github.com/krusemediallc/arcads-claude-code/issues)
- [krusemediallc/arcads-claude-code on GitHub](https://github.com/krusemediallc/arcads-claude-code)
- [License: MIT](https://github.com/krusemediallc/arcads-claude-code/blob/main/LICENSE)
- [README](https://github.com/krusemediallc/arcads-claude-code/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/krusemediallc-arcads-claude-code