sensenova-6.8-code2video-p300

SenseNova 6.8 Code2Video makes short videos by writing code. You give it a written brief. It writes a program that draws the film (animation, text, charts, 3D-style scenes), runs the program to render the video, and revises the code until the result is right. The upstream card lists math explainers, paper-craft films, isometric worlds, kinetic type, data stories, character animation and product promos. The model has 27B parameters and SenseNova fine-tuned it from Qwen3.8-27B. It is licensed Apache 2.0.

Upstream lists the model as image-text-to-text: it takes images and video together with text. This bundle serves the text half only, so this card's pipeline_tag is text-generation, which describes what the endpoint accepts. See "What differs on this package".

This bundle runs the model on 2 Tenstorrent Blackhole chips (mesh P150x2) behind an OpenAI-compatible chat endpoint. It is a tt-model v6 thin bundle for revision 71017a2952b9f66e250c3e2f700f5effff8f1aa0, staged by the tt-orchard harness from a run of that model.

What the model does

This section comes from the upstream model card. None of it was tested on this package.

• Input: a detailed written brief, dense_prompt.md. The authors write it with a stronger general model from a short idea, using their prompt template.
• How it is used: as the model inside a coding-agent harness. The authors use Claude Code with their code-video skill (https://github.com/OpenSenseNova/SenseNova-6.8-Code2Video). The harness gives the model a shell and file tools. The model writes code, renders frames, looks at them, and revises, turn after turn.
• Output: out/final.mp4, plus SPEC.md and VERIFY.md that describe the plan and the checks.
• Length of a job: the authors report runs of more than 10 hours and 2,000 turns at a 512K-token context.
• Revision: you write notes, and the model applies them in the same project folder.

What differs on this package

• Context is 262,144 tokens, half of upstream's 512K. Set the harness's context window to 262,144 or lower. Upstream's Claude Code settings assume 524,288.
• The model cannot see images or video here, although the upstream model can. The launcher skips the vision tower. This run did not try the vision tower. The upstream loop has the model look at rendered frames and revise. On this package that step has to be done by you or by another model. The model can still write and run code and read text output.
• No film has been produced on this package. The checks below compare tokens with a CPU reference on one short prompt and measure decode speed. They say nothing about video quality or about a multi-hour run. At 18.8 tokens per second for one greedy request, a long run will take a long time.

License

The weights this bundle points to are licensed Apache 2.0 (https://www.apache.org/licenses/LICENSE-2.0). The bundle ships no weights. tt-model downloads them from sensenova/SenseNova-6.8-Code2Video with your own Hugging Face account.

What it runs

• Weights: sensenova/SenseNova-6.8-Code2Video at revision 71017a2952b9f66e250c3e2f700f5effff8f1aa0.
• Model code: the Tenstorrent implementation of BAAI/AREX-2, taken from the bundle arex-2-p300. sensenova/SenseNova-6.8-Code2Video has the same text architecture, so only the weights differ.
• At each start the launcher builds model-dir/ from the configuration files of BAAI/AREX-2 (config.json, preprocessor_config.json, video_preprocessor_config.json, shipped in base_config/) and the tokenizer and weights of sensenova/SenseNova-6.8-Code2Video. It sets MODEL_WEIGHTS_DIR and HF_MODEL to that directory, so the chips load the weights of sensenova/SenseNova-6.8-Code2Video.
• Context length 262144 tokens; up to 4 sequences at a time.
• Speculative decoding is off. The drafter of BAAI/AREX-2 needs the MTP tensors of the model, and sensenova/SenseNova-6.8-Code2Video has none.
• Sampling runs on the host, because on-device sampling is not used with the drafter off on this mesh.

Intended use

Use this package as the model behind a coding agent or script that asks for code, such as a Claude Code setup pointed at the endpoint, or direct chat requests for a self-contained animation program. It does not make video by itself: something has to run the code it writes. How the model behaves on the endpoint decides how to call it:

• Thinking is on by default: the chat template makes the model think before it answers unless a request turns thinking off. The server returns the thinking in reasoning_content and the answer in content. (tested 2026-11-03 on one request: the reasoning came back in reasoning_content and the answer in content, which started with two blank lines)
• Reasoning effort can be set per request with chat_template_kwargs and reasoning_effort. The template accepts xhigh, medium, low (default xhigh). (taken from the chat template and run.sh, not tested here)
• Thinking can be turned off per request with chat_template_kwargs set to {"enable_thinking": false}. (tested 2026-11-03 on one request: reasoning_content came back empty and the answer started at once)
• The server parses tool calls into tool_calls (parser qwen3_coder). (taken from the chat template and run.sh, not tested here)
• Text only: run.sh skips the vision tower, so the package does not take images or video, whatever the model accepts upstream. (taken from the chat template and run.sh, not tested here)

How to call it

tt-model serve starts an OpenAI-compatible server. Its port is vLLM's default, 8000, unless you pass --port after the bundle id. The server's model name is the path of the package's model directory, so read it from /v1/models first:

MODEL=$(curl -s http://localhost:8000/v1/models | python3 -c 'import sys, json; print(json.load(sys.stdin)["data"][0]["id"])')
curl http://localhost:8000/v1/chat/completions -H 'content-type: application/json' -d '{
  "model": "'"$MODEL"'",
  "messages": [{"role": "user", "content": "Write one self-contained HTML file that animates a 10-second kinetic-type title card reading TENSTORRENT, using only canvas and JavaScript."}],
  "max_tokens": 32768
}'

This request is an example of the kind of brief the model is built for. It was not run on this package. The reply holds the program in content. Save it and open it in a browser to see the result. To let the model run its own code, put the endpoint behind an agent harness that supplies tools; the server returns tool calls in the tool_calls field.

Expected performance

Every number is labelled. A measured number names its evidence files; the first file holds the value. The files are in this repository under evidence/, at the paths shown, with the run's directory, the home directory and the host name replaced by <RUN_DIR>, <HOME> and <HOST>. TODO means not measured.

Number	Value	Label	Evidence
top1 agreement with the CPU reference, stage 2 (2 chips, bundle arex-2-p300)	0.90625 fraction	measured	stages/2/result.json, stages/2/evidence/swap-check.json, stages/2/evidence/server.log
server ready after start, stage 2 (empty tensor cache)	138.1 s	measured	stages/2/result.json, stages/2/evidence/swap-check.json, stages/2/evidence/server.log
top1 agreement with the CPU reference, this package (stage 7)	0.90625 fraction	measured	stages/7/verify/evidence/verify.json, stages/7/verify/evidence/server.log
server ready after start, this package (stage 7, fresh install, empty tensor cache)	1576.3 s	measured	stages/7/verify/evidence/verify.json, stages/7/verify/evidence/server.log
decode speed, greedy request (stage 2 sampling probe)	18.8 tokens/s	measured	stages/2/sampling-summary.json, stages/2/evidence/swap-check.json
decode speed, sampled request (stage 2 sampling probe)	17.6 tokens/s	measured	stages/2/sampling-summary.json, stages/2/evidence/swap-check.json
decode speed, greedy, 72-token prompt, 256 tokens out, three runs, endpoint benchmark	18.3, 18.5, 18.7 tokens/s	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
decode speed, sampled (temperature 0.7, top-p 0.95), two seeds, endpoint benchmark	17.4 and 17.3 tokens/s	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
time to first token, 72-token prompt, endpoint benchmark	0.29 to 0.38 s (greedy), 0.37 and 0.62 s (sampled)	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
time to first token, 1,632-token prompt, two runs	0.68 s and 0.65 s (2,394 and 2,496 prompt tokens/s)	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
time to first token, 6,432-token prompt, one run	1.84 s (3,492 prompt tokens/s)	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
four requests at once, 72-token prompts, 256 tokens out each, one run	28.5 tokens/s in total; 7.2 to 9.5 tokens/s per request; first token after 0.3 s for one request and 9.1 s for the other three	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json
tt-model serve from the Hub to an open port, first serve on this machine (venv build, 51 GiB weight download, empty tensor cache)	about 47 to 52 min	measured	evidence/benchmark-2026-11-03/endpoint-benchmark.json (the serve log is not kept; the start was 12:19 and the port was open by 13:11, with the last warm-up message at 13:06)

Sampling

Sampled requests (temperature above 0, top-p below 1, with a seed) were served and two seeds gave different text. Their speed is in the table above next to the speed of greedy requests. Stage 2's swap check measured this on one short prompt, served with its own configuration (drafter: off, sampling: host). It sent greedy requests and sampled requests with temperature above 0, top-p below 1 and a seed. The speeds are in the Numbers table, in the rows marked sampling probe. Other sampling settings such as top-k, penalties and logprobs were not tested.

Stage 2 kept the configuration it served. The model needs sampling (the model's own generation_config.json sets sampling defaults) and this configuration applies it. The speeds are in the Numbers table, in the rows marked sampling probe. The decision and the numbers behind it are in evidence/stages/2/sampling-decision.json.

Limitations

• Tested on 2 chips (mesh P150x2) only; other configurations are not claimed by this bundle.
• Accuracy was compared with the CPU reference on one short fixed prompt only.
• Speculative decoding is off, so decode speed is that of plain decoding.
• Sampling runs on the host.

Risks and safety considerations

The check above does not cover long outputs, tool calling or safety behaviour. Output can differ from sensenova/SenseNova-6.8-Code2Video run on a CPU or GPU in ways it does not show.

Not measured

• drafter acceptance on this model (the drafter is off here)
• the sampler check on logits whose maximum sits in the last column of a die (the model has 124,160 columns per die, above the 65,536 limit)
• prompts longer than 6,432 tokens, up to the 262,144-token context
• quality of the code the model writes, and any film made with it
• the vision tower

Boot check

Stage 7 of the run installed this bundle, served it on a leased board and compared its tokens with the CPU reference. The Expected performance table has the result. On 2026-11-03 the package was then served from the Hub with tt-model serve on 2 leased chips and benchmarked through its endpoint; the rows labelled endpoint benchmark come from that run. The benchmark prompts are a repeated filler sentence, so they measure speed and say nothing about answer quality.

How to serve

tt-model serve episod/sensenova-6.8-code2video-p300