In this categoryLocal AI · 75
More guides
Local AIIntermediate

SenseNova 6.8 Code2Video: The 27B Model That Writes Code, Not Pixels, to Make Video

SenseNova 6.8 Code2Video is a 27.36 billion parameter model from SenseNova that builds video by generating and running executable code rather than generating pixels directly. Released October 24, 2026 under Apache 2.0, it is fine-tuned from Qwen3.8-27B and is designed to run inside Claude Code for single sessions that stretch past 10 hours and 2,000 turns.

7 minIntermediate

SenseNova 6.8 Code2Video is a 27.36 billion parameter model from SenseNova that builds video by generating and running executable code rather than generating pixels directly. Released October 24, 2026 under Apache 2.0, it is fine-tuned from Qwen3.8-27B and is designed to run inside Claude Code for single sessions that stretch past 10 hours and 2,000 turns.

SenseNova filed it under Hugging Face's image-text-to-text pipeline, and it climbed into the top 20 of that category not long after release. Instead of a diffusion model painting frames, Code2Video writes a program, runs it, looks at what rendered, and revises the code until the output matches the brief. That loop is the whole product.

Written by Priya Raghunathan, local-AI hardware reviewer. I verify parameter counts, licenses, hardware requirements and every install command against the primary source before recommending a setup path.

A top-20 image-text-to-text entrant

At time of writing the SenseNova 6.8 Code2Video model page shows 89 likes and 770 downloads, and the SenseNova-6.8-Code2Video repository on GitHub has 355 stars. The most-liked Space built around it is a general-purpose VRAM and GPU cost calculator with 22 likes, worth a look before you decide how many GPUs to rent for a production run.

Specs at a glance

FieldValue
PublisherSenseNova
PipelineImage-text-to-text
Base modelQwen3.8-27B
Total parameters27.36B (safetensors total)
Context window512K tokens (524,288)
LanguagesEnglish, Chinese
LicenseApache 2.0
Release dateOctober 24, 2026
Sustained run length10+ hours, 2,000+ agent turns

What code-driven video creation actually means

SenseNova's own tagline for the model is blunt about the approach: every frame is code. Code2Video does not generate a video file, it generates a program that renders one, then watches the rendered output and edits the program when something looks wrong. SenseNova positions this as a deliberate bet on code as a connective layer, since a script can call out to image generators, 3D tools and video editors the same way it can draw a shape, chaining separate tools into one pipeline instead of training a single model to do everything.

The model card lists the styles this approach already covers well: math explainer videos, paper craft style films, isometric world fly-throughs, kinetic typography, data driven stories, character animation and product promos. SenseNova is upfront that this is a first step, limited to short, fully code-rendered videos for now, with plans to extend it toward editing, compositing and 3D work.

Running it: three serving options, all multi-GPU

SenseNova publishes ready-to-run Docker commands for LightLLM, vLLM and SGLang, and all three examples use a tensor-parallel size of 4. At 27.36B parameters, weights alone come to roughly 54 to 55 GB in bf16, before the KV cache needed for a 512K context, so plan for a multi-GPU box rather than a single consumer card. The vLLM path:

bash - serve SenseNova 6.8 Code2Video with vLLM
$docker run --rm --gpus all --ipc=host -p 8000:8000 \
$ -e VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 \
$ -v /path/to/SenseNova-6.8-Code2Video:/model \
$ vllm/vllm-openai:latest \
$ --model /model \
$ --tensor-parallel-size 4 \
$ --max-model-len 524288 \
$ --reasoning-parser qwen3 \
$ --enable-auto-tool-choice \
$ --tool-call-parser qwen3_coder \
$ --host 0.0.0.0 --port 8000
$

LightLLM and SGLang follow the same shape, swapping --tensor-parallel-size for --tp or --tp-size and pointing the context flag at the same 524,288 token limit. Pick whichever serving stack your existing inference setup already standardizes on.

Why it needs an agent harness, not a one-shot prompt

A finished film is not one inference call, it is an open-ended loop of writing code, rendering it, checking the frames and fixing what is wrong, and SenseNova says that loop routinely runs past 10 hours and 2,000 turns for a single video. The model card's recommended harness is Claude Code, pointed at your self-hosted endpoint and tuned so it does not quietly cut the run short.

SettingValueConfiguration
Context window512KCLAUDE_CODE_MAX_CONTEXT_TOKENS=524288
Auto-compaction0.8CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80
Max output64KCLAUDE_CODE_MAX_OUTPUT_TOKENS=64000
Turns per run2,000+--max-turns 2000 or more
Time per run10h+timeout 10h or more
Set the context window explicitly
Claude Code treats an unrecognized model as a 200K-context model by default. Without CLAUDE_CODE_MAX_CONTEXT_TOKENS set to 524288, it will compact or truncate long production runs well before SenseNova 6.8 Code2Video actually runs out of room.

Point the harness at your deployment through a private settings file rather than shell exports, since the model card ships one:

private-settings.json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://your-endpoint.example.com",
    "ANTHROPIC_MODEL": "your-deployed-model-name",
    "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "524288",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80",
    "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "64000"
  },
  "model": "your-deployed-model-name"
}

The three-stage production workflow

SenseNova splits a film into three stages, and only the middle one runs on Code2Video itself. A strong general model, SenseNova used Claude Opus 5.5, expands a short brief into a dense_prompt.md using the project's enhance-prompt template. Code2Video then runs that prompt inside Claude Code using the code-video skill from the GitHub repo, producing out/final.mp4 alongside SPEC.md and VERIFY.md. An optional third pass lets the creator hand back notes and have Code2Video revise the same project rather than starting over.

bash - run the production stage
folder contains dense_prompt.md, assets/ and .claude/skills/code-video
$cd /path/to/task
$claude -p --settings /path/to/private-settings.json --model your-deployed-model-name \
$ --max-turns 2000 --permission-mode acceptEdits --allowedTools "Bash,Read,Write,Edit,Glob,Grep,Skill" \
$ 'Use the project code-video skill. Read .claude/skills/code-video/SKILL.md and dense_prompt.md, then the relevant craft guides. Produce the complete video and deliver out/final.mp4, SPEC.md and VERIFY.md.'
$
Run it isolated
This invocation uses --permission-mode acceptEdits, so the agent executes shell commands without asking first. SenseNova's own guidance is to start it in an isolated working environment rather than a machine with anything you cannot afford it to touch.

For a revision pass, run claude -p --continue in the same folder with the creator's notes as the prompt, instead of rebuilding the project from scratch.

Trajectories, if you want to see the loop itself

SenseNova shipped one complete production trajectory per line in trajectories/all.openai.jsonl, in OpenAI messages format, with reasoning, tool calls, retries and compaction summaries intact. All 357 figures referenced in those logs sit in trajectories/figures. Paths and hosts are anonymized, so the logged commands will not replay as-is, but they are a genuinely useful read for understanding what 2,000 turns of code-and-check actually looks like turn by turn.

License and use

SenseNova 6.8 Code2Video ships under Apache 2.0, so commercial use, modification and redistribution are allowed without a separate agreement. The model card lists no gated dependencies, which simplifies deployment compared to pipelines that lean on separately licensed encoders.

FAQ

What is sensenova/SenseNova-6.8-Code2Video?

It is an open model that creates video by generating and executing code rather than generating pixels directly. It is fine-tuned from Qwen3.8-27B by SenseNova and released under Apache 2.0.

How many parameters does it have?

27.36 billion parameters, per the model's safetensors total on Hugging Face.

Can I run it on one consumer GPU?

Not practically. SenseNova's own deployment examples for LightLLM, vLLM and SGLang all use a tensor-parallel size of 4, and the weights alone run roughly 54 to 55 GB in bf16 before accounting for the KV cache the 512K context needs. Plan for a multi-GPU server, not a single card.

Why does it need Claude Code instead of a normal API call?

Producing one film is a long agent loop of writing code, rendering it, reviewing frames and fixing problems, which SenseNova says routinely takes more than 10 hours and more than 2,000 turns. Claude Code is the harness SenseNova tuned for sessions that long, with explicit settings for context window, auto-compaction and max output so the run does not get cut short partway through.

Is it free for commercial use?

Yes. Apache 2.0 permits commercial use, modification and redistribution without additional permission.

Where to go from here

Local models run better with more VRAM. CompareRTX GPUs on Amazonbefore you upgrade.(affiliate link. We may earn a commission at no extra cost. Disclosure)

Watch related tutorials

Free weekly email

Weekly local AI drops

New models, what runs on your hardware, and the guides to set them up. One email a week, unsubscribe any time.

Tags
#sensenova code2video#code2video ai model#code driven video generation#run sensenova code2video locally#image text to text video model#claude code long running agent