AI Guides

How to Create AI Explainer Videos With Astra, Sol 6.1, Fable and Opus

Turn one useful idea into a video people can understand. Choose a model, build an editable production, and check the result before you publish.

Sources checked and materially revised November 13, 2026 · Prices in USD · Focuses on GPT-6 Astra, GPT-6.1 Sol, Claude Fable 5.2 and Claude Opus 5.5; includes GPT-6.1 Terra, legacy Fable 5.1 and current asset tools where relevant

Start with a question your viewer needs answered. “How does this work?” “What changed?” “How do I complete this task?” A good explainer gives that question a visible answer: a process unfolds, a comparison becomes clear, or a demonstration shows the next step.

Astra, Sol 6.1, Fable and Opus can help research the subject, write narration, plan scenes and build animation code. With an agent, renderer and the right assets, they can also help produce and revise the video. The quality depends on what you ask them to explain and whether the finished visuals support it.

What these models can do for a video

Think of the production as four jobs. The language model develops the explanation and writes instructions or code. The agent gives it access to files and tools. Media tools supply narration, images or footage. The renderer turns the timeline into a video file.

All four models accept text and images and return text in their base APIs. They do not directly return an MP4 through those base modalities. A connected application may create media using other tools. The official Astra, Sol 6.1, Fable 5.2 and Opus 5.5 pages document that distinction.

01Explain

Verified sources become a clear script.

02Design

The script becomes timed visual scenes.

03Produce

Scenes become animation and narration.

04Verify

The rendered video is reviewed and corrected.

The model can coordinate the work. Each stage still needs the appropriate tools, assets and review.
Documented base API specifications · November 13, 2026
Model API identifier Context window Maximum output
GPT-6 Astra gpt-6-astra 1,050,000 tokens 128,000 tokens
GPT-6.1 Sol gpt-6.1-sol 1,050,000 tokens 128,000 tokens
Claude Fable 5.2 claude-fable-5-2 1 million tokens 128,000 tokens
Claude Opus 5.5 claude-opus-5-5 1 million tokens 128,000 tokens
GPT-6.1 Terra (supporting model) gpt-6.1-terra 1,050,000 tokens 128,000 tokens

These are capacity limits, not recommended project sizes. Fable 5.2 is the current successor to Fable 5.1, which remains active but is marked legacy. Terra is included as a supporting model; the guide’s four-model focus is unchanged. Opus also documents a separate 300K-output Batch API beta; the table shows the ordinary output limit. Send the material a stage needs rather than your entire archive.

Choose a model around the hardest part

Use a model you can access in an environment that can do the work. A more capable model in a chat-only interface may give you a plan; a coding agent with a renderer can turn the same brief into files and a preview.

Sol 6.1 for building and frequent revisions

Sol is our starting choice for a clearly defined subject, reusable graphics and repeated edits. Ask it to keep narration, timings, labels and chart values in editable data. That makes requests such as “replace the price in scene four” easier to implement and inspect.

OpenAI’s Sol documentation positions it for complex coding and professional work at a lower cost than Astra. For API tool calling, use the Responses API. Supported API reasoning efforts are low, medium, high, xhigh and max; medium is the default.

Opus 5.5 for a complete production project

Try Opus for a project that combines writing, actual product captures and an implementation you expect to maintain. For an onboarding explainer, supply the approved feature list and real screenshots, then ask which scenes require a demonstration and which can use a diagram.

Anthropic documents Opus 5.5 for long-running agentic coding and knowledge work. It was released September 22, 2026, and its default effort is medium. Our suggested production role is an editorial judgment, not a measured advantage over Sol.

Astra for difficult mechanisms and implementation problems

A heat-pump explainer needs to distinguish the refrigerant loop from indoor and outdoor air and show where heat enters and leaves. Icons floating across the screen will not establish those relationships.

Give Astra a verified source diagram and ask it to identify what each scene must prove, where an analogy breaks, and which simplifications would change the meaning. Then request a prototype of the hardest scene. OpenAI positions Astra for demanding reasoning, coding, research and computer use.

Fable 5.2 for demanding research and synthesis

Try Fable when the explanation depends on several technical sources or a simulation that must agree with the narration. Ask for a claim ledger before a script: the claim, its evidence and any unresolved disagreement.

Anthropic released Fable 5.2 on November 9, 2026 for demanding reasoning and long-horizon agentic work. Its Claude API ID is claude-fable-5-2, adaptive thinking is always on, and the default effort is high. It is available to all Claude API customers and on the listed AWS, Google Cloud and Microsoft Foundry routes. Its premium price still makes a bounded research, mechanism review or stubborn scene-repair assignment a sensible first test. Routine layout changes can return to your production model.

Fable 5.2 requires 30-day data retention and is not available under zero-data-retention terms unless Anthropic expressly authorizes it. For a 5.1 pipeline, follow the migration guide: update the model ID, replay a saved explainer project, replace the older computer_20251124 tool outside Bedrock, and update a Managed Agents advisor to Fable 5.2 or Mythos 5.2. Do not assume Fable 5.1 thinking blocks remain reusable. Those are vendor requirements; whether the model improves a particular video still needs a representative evaluation.

Terra 6.1 for visual review and screen-based assembly

OpenAI released GPT-6.1 Terra on October 26, 2026. Its API ID is gpt-6.1-terra. The base model accepts text and images and returns text; it does not directly generate image, audio or video output. OpenAI positions it for visual reasoning, precise computer use and clear writing. API tool calling requires the Responses API.

Our editorial suggestion: use Terra as a lower-cost supporting worker to compare storyboard frames with approved references, flag cropped labels, inspect product captures and organize screen-based assembly. Give it a checklist and require a finding for every scene. Keep final factual and editorial approval with a reviewer, and use a media tool or renderer for the actual assets and MP4.

Use smaller workers and a stronger advisor deliberately

Claude Haiku 5.5, released October 7, 2026, adds a lower-cost option for supporting tasks. Its API ID is claude-haiku-5-5; it accepts text and images and returns text, with a 1M-token context and 128K ordinary output limit. Input/output rates start at $0.10/$0.50 per million tokens for prompts up to 100,000 tokens; above that threshold they rise to $0.50/$2.50.

Our editorial suggestion: try it for asset tagging, extracting scene IDs or checking that required fields exist. Keep the causal explanation and final judgment with your chosen production model. Cheap workers still need sample checks.

Anthropic also documents an advisor strategy: an executor handles routine turns and consults a stronger model for difficult decisions. For an explainer, test Opus 5.5 as executor with a bounded Fable 5.2 review of a confusing mechanism or recurring failure. The API advisor tool is beta, and a Fable 5.2 executor requires a Fable 5.2 or Mythos 5.2 advisor. Measure whether consultations occur, whether they improve the scene, and their added tokens and delay. Compare the pairing with raising the executor’s effort or using Fable alone; savings and quality improvements are not guaranteed.

Compare the repair work, too

Give the candidates the same small brief: one confusing mechanism, one crowded frame and one revision request. Compare factual accuracy, visual clarity, runnable output, time to an acceptable preview and total cost. Include every repair attempt.

A prompt saying “use Astra for research and Opus for writing” does not switch providers. Your application must route the calls and transfer the approved artifacts, or you must select each model yourself.

Choose how you will build the video

Choose the production route before asking for a finished project. It determines the files, instructions and tools the model needs to provide.

Route A: assemble it in a visual editor

Use this route if you want direct control over the timeline without maintaining animation code. Have Sol or Opus produce the script, storyboard, asset list and narration directions. Assemble the scenes in an editor you already know.

  1. Capture product behavior or gather verified diagrams and photographs.
  2. Arrange six to eight scenes around a scratch voice track.
  3. Add editable labels, highlights and captions inside the editor.
  4. Review the sequence, make specific corrections and export.

Without authorized access to your editor, the model’s deliverable is an assembly plan. Ask it to identify the files it created and the steps you still need to perform.

Route B: let a coding agent build editable motion graphics

This works well for process diagrams, comparisons, pricing cards and recurring updates. The agent builds reusable scene components; structured data supplies the text, timings and values.

Remotion’s official setup guide provides this command-line starting pattern. You need Node.js and a working execution environment.

Create and preview a blank project

npx create-video@latest --yes --blank --no-tailwind ai-explainer
cd ai-explainer
npm i
npx remotion skills add
npm run dev

Give the agent your approved storyboard. Ask it to register a composition named Explainer and build a title card, document card, arrow, callout and recap scene. Keep content in a scene-data file and animation tied to the render’s frame number.

Prove a ten-second segment first. Check the text, narration, media paths and export. Once the full composition exists, Remotion’s rendering workflow supports a command such as:

Render your registered composition

npx remotion render Explainer out/explainer.mp4

The setup commands create a starting project; they do not implement the explainer. The render command requires the matching composition and its assets. Check Remotion’s license for your organization before production use.

Route C: use precise diagrams, simulations or 3D

Choose a tool such as Manim for mathematical animation, or a 3D renderer for a mechanism whose spatial relationships matter. Give the model real equations, units, part names, scale and permitted motion.

Request one clear camera angle or one correct plotted example before adding effects. Label simulations as simulations, preserve calculated values, and check that the narration matches the behavior shown. API model access and the machine that renders the scene are separate.

The eight-step production workflow

1. Define one learning outcome

Complete this sentence: “After watching, the viewer will be able to…” Make the result observable. “Understand AI” is too broad. “Explain why a retrieval system looks up documents before answering” gives you something to test.

Record the audience, duration, destination, required claims, available assets, budget and next action. A short video can introduce one mental model or complete one task. Broader subjects need separate lessons.

2. Gather sources and record the claims

Supply official documentation, actual screenshots, verified figures and relevant diagrams. Date information that changes, including prices, plan limits and model versions.

A small claim ledger is enough: claim ID, wording, source, location, date checked and uncertainty. Map the script to those IDs. For a tutorial, record the account state and product version being demonstrated; remove features you cannot verify.

3. Work out the explanation, then write narration

Describe what enters the system, what changes and what comes out. Identify the misunderstanding the video must prevent. Choose an analogy only if it makes those relationships clearer, and explain where it stops working.

For initial planning, try 120–150 spoken words per minute. Dense concepts and demonstrations may need fewer. Time a scratch read before fixing scene durations; the measured read matters more than the word count.

4. Turn narration into a timed storyboard

Give each scene an ID, start time, duration, narration, on-screen text, motion, source IDs and asset dependencies. Ask what becomes clearer because the viewer sees the scene.

“Show futuristic AI graphics” gives a designer little to work with. “Highlight the relevant paragraph, move it beside the question, then reveal the answer” specifies a visible relationship. List missing assets now, before they delay the render.

5. Establish a small visual system

Use a limited palette, consistent typography and one icon style. Assign colors a meaning and preserve it: blue source documents, gold retrieved passages, green answers.

Design the most crowded frame first. Keep labels, prices, numbers and captions as editable text. Use motion to show sequence or causality; give the viewer one focal point at a time.

OpenAI released GPT Image 2.6 on November 4. Use gpt-image-2.6-sunburst for detailed visual work and gpt-image-2.6-flare for faster iteration. Both generate and edit raster images, support transparent backgrounds and custom sizes, and add adjustable complexity, markup-guided edits, SVG output and animated GIF output.

For an explainer, SVG is useful for editable icons and illustrations; inspect the returned paths, labels and accessibility before use. A GIF can prototype a short loop with 2–16 frames, but it is not a narrated timeline or an MP4. Keep factual labels, prices and interface text in editable layers. Use the renderer for timing, captions and final export.

The two GPT Image 2.6 models share published token rates: $8 per million image-input tokens, $2 per million cached image-input tokens, $30 per million image-output tokens, $5 per million text-input tokens and $1.25 per million cached text-input tokens. SVG also bills the authoring model used to produce the vector. Cost per asset varies with size, quality, complexity, references and retries. Test one representative frame with fixed settings before scaling; do not treat one prompt as a universal benchmark.

6. Make a rough preview

Build an animatic with simple shapes, draft narration and approximate transitions. Watch it for order, clarity and pacing before paying for detailed assets.

Repair a specific learning problem: “The answer’s source is unclear. Add the same source marker to the selected document and answer.” Keep the last working project so a failed revision does not force a rebuild.

7. Finalize narration, captions and sound

Check pronunciation of names, acronyms and numbers. Where practical, create narration in scene-sized segments so one future change does not require a complete retake. Retime the visuals to the final audio.

Keep music below speech, give important diagrams a moment to register, and build captions from the final recording. Check names, punctuation and timing. Deliver a separate caption file even if you also burn captions into a social version.

OpenAI’s speech guide requires clear disclosure that its TTS voice is AI-generated. Follow the terms of your voice provider and obtain permission for any cloned voice.

8. Export and inspect each format

A useful working master is 1920 × 1080 for landscape video. Build a separate 1080 × 1920 composition for vertical distribution and check the destination’s current requirements.

Recompose diagrams and UI steps for the phone screen. Cropping can remove a label or arrow that carries the explanation. Review every export from beginning to end, then deliver the MP4, captions, poster frame and editable source.

A worked 60-second explainer

The subject is retrieval-augmented generation, or RAG: finding relevant source material and supplying it as context for an answer. The viewer has used a chatbot; the learning outcome is to distinguish a lookup at answer time from retraining a model. OpenAI’s retrieval guide provides implementation detail.

This is an original storyboard and draft narration. It is not a rendered video or a four-model test result.

1. Ask

“What is our refund policy?”

The question needs company-specific information.

2. Retrieve

Find the relevant passage in the approved policy.

Source material is selected at answer time.

3. Answer

Use the question and passage to draft a sourced answer.

Check the source; retrieval can still fail.

This lookup supplies context for an answer. It does not retrain the model.

Draft narration

You ask an AI assistant, “What is our refund policy?” A general model may not know your company’s current rules. Retrieval-augmented generation gives it a way to look them up.

First, the system searches the documents it has access to. It selects passages relevant to the question, such as your approved refund policy.

Those passages are supplied to the model alongside your question. The model uses that context to draft an answer and, when the application provides them, point to its sources.

This lookup does not retrain the model. It gives the model information for this answer.

But retrieval is not a guarantee of correctness. An old policy, a missing passage or a mistaken interpretation can still produce a bad answer.

The useful workflow is: ask, retrieve, answer—and check the source when it matters.

Record a scratch read before locking the duration. The scene timings below are a starting plan; adjust them to the voice and pauses.

Five scenes that teach one mechanism
Time Visible action What the viewer learns
0–10s The refund question appears beside an empty answer panel. A company-specific answer needs company-specific information.
10–22s Document cards appear. The approved policy and relevant paragraph are highlighted. Retrieval selects relevant source material.
22–36s The question and passage enter a model panel. An answer appears with a matching source marker. The selected passage informs the answer.
36–49s A “lookup” label appears. An outdated policy demonstrates how a bad source can change the answer. Lookup differs from retraining and can still fail.
49–60s Ask → Retrieve → Answer appears, followed by “Check the source.” The process and one practical review habit.

For a useful model comparison, give each candidate this exact brief and identical assets. Then request the same revision: replace the outdated-policy scene with a missing-document example while preserving duration and learning outcome. Check whether the edit works, introduces factual errors or breaks the layout.

What an AI explainer actually costs

Budget three things separately: model usage, the tools and assets used to produce the video, and the time spent reviewing it. A cheap script response tells you little about the finished production cost.

Standard API token prices

Rates below are per million tokens, checked November 13, 2026. OpenAI figures use Standard short-context pricing. Sources: OpenAI API pricing and Claude API pricing, with cache rates checked against the model pages.

USD per million tokens · Standard rates
Model Input Cache read Cache write Output
GPT-6.1 Sol $2 $0.10 $2.50 / 30 min; $5 / 12 hr $10
GPT-6.1 Terra $1 $0.05 $1.25 / 30 min; $2.50 / 12 hr $5
Claude Opus 5.5 $4 $0.20 $5 / 5 min; $8 / 1 hr $20
GPT-6 Astra $10 $1 $12.50 / 30 min; $25 / 12 hr $50
Claude Fable 5.2 $8 $0.20 $10 / 5 min; $16 / 1 hr $40

On a narrow screen, scroll inside the table to see every column.

For Astra, Sol and Terra, prompts above 272,000 input tokens use twice the input and cache rates and 1.5 times the output rate for the full request. Batch and Flex are half Standard; Fast is twice Standard. Fable 5.2 and Opus 5.5 include their full one-million-token windows at standard per-token rates; their model pages list a 50% Batch discount on input and output. Account, region and tier conditions can change the bill.

OpenAI added an optional 12-hour prompt-cache duration on October 20, 2026. Its write price is 2.5 times uncached input, versus 1.25 times input for the 30-minute write; cache reads retain the listed discounted rate. The 12-hour option is useful only when the same stable instructions, tool definitions or reference context will be reused across a longer production session. Record cache hits and invalidate the cache deliberately when claims, brand rules or source material change.

Internal reasoning also consumes billed output tokens. Use reported usage, not the visible script length, when calculating cost. See the OpenAI reasoning guide and Claude thinking and cost guide.

Two illustrative model-usage budgets

These are calculations, not measured production results. Both assume uncached input, total billed output including reasoning, and individual requests within the short-context threshold.

Model calls only; media and review are additional
Model 100K input + 20K output 1M input + 200K output
Sol 6.1 $0.40 $4.00
Terra 6.1 $0.20 $2.00
Opus 5.5 $0.80 $8.00
Astra $2.00 $20.00
Fable 5.2 $1.60 $16.00

Calculation: input tokens ÷ 1,000,000 × input price, plus billed output tokens ÷ 1,000,000 × output price. Add cache writes and reads when used. These examples exclude tool calls, media generation, rendering, storage, taxes and human review.

Long agent sessions repeatedly read files, tool results and conversation history. Preserve a concise brief, send the sources needed for the next stage, and revise a scene instead of regenerating the entire project.

Faster responses have a separate price

OpenAI’s October 8, 2026 changelog adds Ultrafast support for Sol 6.1. The current guide supports both Astra and Sol 6.1 for all API users, subject to separate rate limits. In the Responses API, select the model and set service_tier: "ultrafast". Persistent WebSocket connections can reduce overhead across repeated tool calls.

Ultrafast short-context API rates · USD per million tokens · November 6, 2026
Model Input Cache read 30-minute cache write Output
GPT-6.1 Sol $12 $0.60 $15 $60
GPT-6 Astra $60 $6 $75 $300

These Ultrafast rates are six times Standard. The same uncached 100K-input/20K-output example costs $2.40 with Sol and $12 with Astra. Above 272K input tokens, input/cache rates double and output rates multiply by 1.5. Ultrafast speeds model output; it does not accelerate the video renderer or guarantee better explanations.

For the new 12-hour cache duration, Ultrafast write rates are $30 per million tokens for Sol 6.1 and $150 for Astra. Use the longer duration for repeated work spread across hours, not as a default: it changes cache-write cost, not the output rate or the renderer’s speed.

Our production recommendation: use Standard for planned script and scene work, and test Ultrafast when waiting between interactive edits is the bottleneck. Measure total time to an acceptable preview and cost.

API access is separate from subscription access: Work and Codex pricing lists Ultrafast on Pro $500 and eligible Enterprise/Edu plans. Claude Fast mode is another distinct option: Fable 5.2 is $16 input/$80 output and Opus 5.5 is $8 input/$40 output per million tokens on supported routes, with caching and regional modifiers applied separately; Fast is unavailable with Batch.

For Opus 5.5 Fast, set speed: "fast" and inspect usage.speed in the response. Unlike older Opus Fast previews, Opus 5.5 does not need the preview beta header. Switching between Standard and Fast invalidates the shared prompt-cache prefix, so price a mid-project switch rather than assuming an existing cache hit survives.

Subscriptions and API billing are separate

Subscription usage is not an API invoice. OpenAI’s current usage table lists Ultrafast at 8× included subscription usage, versus 6× purchased-credit and Enterprise pay-as-you-go usage. Those are usage multipliers, not promises about finished videos. If you reuse an old coding workflow, the October 14, 2026 Codex retirement notice says to replace saved gpt-5.5 selections when signed in with ChatGPT; API-key sessions are unaffected. Choose Sol 6.1 where available.

Eligible ChatGPT subscriptions can include API credits. OpenAI’s program lists $100, $200 or $500 per month for the corresponding paid Pro tier. Business receives $20 per paid Standard seat or $100 per paid Premium seat, pooled up to $500 per workspace per month. The subscription must be active and at least seven days old; the subscription owner must also own the receiving API organization and use the same email address. The first grant is prorated, unused credits expire at the end of the billing cycle, and Plus, Go, Free and Enterprise are not eligible.

OpenAI’s credits cover paid usage in the linked API organization, including Responses, Agents, Decisions, GPT-Live/Realtime, Images and built-in tools. They do not increase ChatGPT or signed-in Codex limits, and Codex usage through API keys is excluded. Track gross usage and the applied credit separately; it does not pay third-party narration, footage, rendering or review labor.

Claude subscription credits can offset eligible API work. Anthropic’s current program includes $100/month in Claude Platform credits with Max and $200/month with Ultra. Team credits are $20 per Standard seat or $100 per Premium seat, pooled up to $500/month. Free, Pro and Enterprise plans are excluded. Credits expire each billing cycle without rollover and do not cover Claude Code or extra usage in the Claude apps.

OpenAI’s plan documentation lists Plus at $20/month and Pro options at $100, $200 and $500/month. Check included usage and model access in your account; API prices cannot tell you how many videos a subscription includes. Sol 6.1 and Terra 6.1 are available in Work and Codex, with administrator controls for Enterprise and Edu. Terra is not available in Chat.

Claude pricing lists Pro at $20 monthly or $200 annually, Max at $100/month and Ultra at $200/month. Fable 5.2 is available on all paid plans, but access is billed differently: Max, Ultra and premium Team seats include Fable for up to half the weekly limit, while Pro and standard Team seats normally use pay-as-you-go usage credits. Anthropic’s dated November 9 launch offer temporarily gives eligible Pro and standard Team seats one week of Fable use up to 50% of weekly limits plus a reset; other eligible paid seats receive one to three resets. Treat that as a promotion, not a permanent plan feature, and confirm access and extra-usage settings before a long session.

Allow for the rest of the production

Examples of supporting costs · November 13, 2026
Component Published example What to budget
Editable motion graphics Remotion: free for individuals and companies of up to three people, subject to terms. Company creator seats are $25/month; automation is $0.01/render with a $100 monthly minimum. The appropriate license and separate rendering infrastructure.
AI narration ElevenLabs: Starter $6/month; Creator $22/month before first-month promotions. Starter includes a commercial license. Retakes, translations, shared credit consumption and the chosen voice’s terms.
Generated footage Runway Standard: $15 monthly or $12/month billed annually; 625 monthly credits. Gen-4.5 uses 60 credits per five seconds. Attempts as well as usable shots. At that rate, 625 credits cover about 52 generated seconds.
Assembly and review Your editor, hardware and review time. Include labor even when you already own the software.

Four five-second Gen-4.5 shots cost 240 credits for one attempt each. Three attempts per shot cost 720 credits, exceeding Standard’s monthly allowance. That is arithmetic using the published rate; it is not an estimate of Runway’s success rate.

Separate monthly commitments from the cost allocated to one finished video. For example, $20 of allocated software, $4 of model calls, $6 of other production charges and two review hours at $40/hour total $110. Those are planning assumptions, not vendor quotes or a promised production time.

Match the visual format to the task

Choose visuals that answer the viewer’s question. Real product behavior needs real captures. A causal process needs a diagram. Generated footage can support atmosphere or an illustrative moment, but exact labels and numbers belong in editable layers.

Choose the evidence the viewer needs
Use case Viewer’s goal Useful visual format
SaaS onboarding Complete one task Real screen recording, focused callouts and visible success state
AI concept education Understand a mechanism Progressive diagram and one concrete example
Product launch Understand the benefit and its evidence Actual product footage with concise explanatory graphics
Internal training Follow a procedure correctly Step demonstrations and decision points
Math or science See why a result occurs Equations, plots and a checked simulation
Hardware explanation Understand parts and movement Labeled diagram or accurate 3D cutaway
Weekly model update Know what changed Sourced comparison and editable pricing cards
Multilingual lesson Learn the same idea in another language Adapted narration, retimed scenes and redesigned text

A marketing explainer needs a problem, mechanism, proof and action. An educational explainer needs a question, mental model, example and recap. A tutorial needs prerequisites, exact steps and a way to recognize success. Decide the job before writing the script.

Copyable prompts for a complete production

Fill in the brackets and provide the assets before you start. Use the master brief for the project, then the scene and review prompts for focused revisions.

The master brief

Copy and adapt · Project brief

Create an explainer using the tools available here.

Topic: [one specific topic]
Audience and prior knowledge: [describe]
Learning outcome: After watching, the viewer can [observable result].
Duration and formats: [duration; 16:9 and/or 9:16]
Verified sources and dates: [links or files]
Approved claims: [list]
Claims to avoid: [list]
Available assets: [screenshots, recordings, logos, diagrams]
Visual style and voice: [describe]
Production route: [visual editor / editable motion graphics / 3D]
Paid-tool budget: [amount; obtain authorization before spending]

Deliver:
1. Claim ledger and unresolved evidence gaps.
2. Narration and timed storyboard.
3. Editable assets or source project.
4. Rough preview using available local/free resources first.
5. Concrete quality findings and corrections.
6. Final export, captions and source files when execution is available.

Keep labels and numbers editable. Distinguish illustrative scenes
from actual demonstrations. Do not invent behavior, statistics
or citations. State which files were created and inspected.
If a tool is unavailable, identify the exact remaining dependency.
Do not describe an unrendered project as a finished video.

A storyboard that shows the explanation

Copy and adapt · Scene planning

Turn the approved script into a production table.
For every scene include:
ID, duration, narration, on-screen text, visible objects,
motion, source claim IDs, asset dependencies and learning purpose.

Make one relationship or step clear in each scene.
Use one focal point at a time.
Use exact diagrams for mechanisms and real captures for UI steps.
Flag sentences that cannot fit the available time.
Replace vague visual directions with specific visible actions.
Do not cover an unclear explanation with generic technology footage.

A brief for optional generated footage

Copy and adapt · One illustrative shot

Prepare a short illustrative shot for [scene ID].
Subject: [specific object]
Action: [one action]
Setting and lighting: [describe]
Camera: [fixed angle or one movement]
Reference asset: [supplied image, if supported]
Constraints: [shape, brand details and continuity to preserve]

Keep the background simple. Leave room for an editable label;
do not generate the label inside the footage.
Use the video model's supported duration and aspect ratio.
Identify what is illustrative rather than factual evidence.

Kingy AI’s AI Video Script Generator and AI Video Prompt Generator can help prepare drafts. They do not render or verify the finished video.

A focused review

Copy and adapt · Review the supplied output

Review the storyboard, final transcript and rendered frames supplied.
Do not assume you can inspect media that was not provided.

Check factual claims against the claim ledger, visual/narration
agreement, causal direction, numbers, units and chart axes.
Check readability, contrast, clipping, caption space and pacing.
Check differences between the script and final narration.

Return concrete issues with scene IDs and proposed fixes.
Separate observed defects from possible concerns.
Revise affected scenes, then render and inspect the changes
when the environment provides those capabilities.

Quality checks that improve the explanation

Technical success and learning success need separate checks. A file can render perfectly while teaching the wrong idea.

Common problems and targeted repairs
Problem What to change
The polished video teaches little Give each scene a question to answer. Animate the relationship, mechanism or decision.
The script is too dense Keep one learning outcome and move secondary detail into a separate lesson.
Labels change or contain errors Replace text embedded in generated media with editable text layers.
Product behavior looks invented Use verified recordings and show the actual success state.
Narration and animation disagree Retime visuals against the final audio and transcript.
The preview works but export fails Check the error and asset paths. Repair the smallest failing scene.
Retries keep raising the cost Set a spending limit and preserve the working version. Repair affected assets.
The vertical version is unreadable Redesign the composition with larger labels and fewer simultaneous objects.

Before release

  • Check facts, source dates, causal relationships, units and numbers.
  • Confirm that demonstrations and illustrative scenes are distinguishable.
  • Watch on a phone. Keep essential labels readable and meaningful without color alone.
  • Listen for pronunciation and speech clarity; check captions against final audio.
  • Inspect each export from its first frame to its last.
  • Confirm the permissions needed for assets, fonts, music, footage and voices.
  • Remove private information from captures and save the editable project with its sources.

Show the draft to someone in the intended audience. Ask them to explain the mechanism or complete the task without replaying it. Their answer tells you where the explanation still fails. Fix that before adding more effects.

Trace the bottleneck before changing models

Anthropic’s October 14, 2026 release notes introduced OpenTelemetry export in beta for Messages API requests and Managed Agents sessions. The tracing guide explains how to inspect model calls, tool calls and token usage. Metadata-only mode is the default; full-content mode can export prompts and responses to your observability provider.

Our editorial application: attach a project and scene ID to your own production records, then separate time spent reasoning, generating assets, retrying tools and rendering. If a render takes most of the time, a faster language-model tier may save little. Compare the same ten-second scene and revision before and after a change. Count one authoritative usage source per request rather than adding SDK and API spans together. Review access and retention settings before exporting client scripts, recordings or other private material.

For organization-level cost attribution, Anthropic’s beta Usage and Cost Analytics API reports requests, tokens and USD cost by model, workspace, API key, actor and other dimensions. The usage and cost endpoints require the analytics-usage-cost-2026-08-24 beta header. Data typically refreshes within four hours but can take up to 24 hours and can be revised for late events. Use a dedicated workspace or API key for the production, retain your own project and scene IDs, and reconcile only after the provider data has settled.

Use short-lived message threads for active Claude edit loops

Anthropic released message threads in beta on November 2, 2026. With the message-threads-2026-08-12 beta header, a long Messages API conversation can send only the new messages after the first request instead of uploading the complete history every turn. Anthropic says this can reduce request size and keep time to first token steadier; it does not change the Fable or Opus token rates above.

A thread expires five minutes after its last request and is deleted no more than one hour after last use. It is not eligible for zero-data-retention or HIPAA workloads. Our editorial use: try it during an active scene-repair loop, but store the approved brief, claim ledger, storyboard and final files outside the thread so an expiry cannot erase the production record.

Pin and test the Claude API version

Anthropic released API version 2026-10-21 on October 21, 2026, and new major SDK versions use it by default. The migration guide lists breaking changes; for example, a document block placed directly in an assistant message now returns a 400 error and must be sent in a user message. If you call the API without an SDK, set anthropic-version: 2026-10-21. Amazon Bedrock supports this version only for Claude 4.7 and later.

For a production pipeline, pin the SDK and API version, test one saved brief through research, storyboard, asset handoff and final structured output, then promote the upgrade. Keep the previous lockfile and a known-good test project until the new version passes. Apply the separate Fable 5.2 model migration requirements above when changing that model ID.

Make the next video easier to produce

Keep the brief, approved claims, narration, scene data and brand settings separate. Give claims and scenes stable IDs so an update can identify exactly what must change.

Save an asset manifest with paths, sources, usage permissions and the scenes using each asset. Record the model, prompt version, production date and actual cost. For recurring pricing or product explainers, store changeable values in data rather than baking them into pictures.

An automated process can check sources, draft updates, validate data and render a preview. Review the meaning as well as the output: changing a price card is a small edit; changing the underlying explanation may affect every dependent scene.

Set a budget and retry limit, preserve the last successful version, and report a specific blocker when a scene repeatedly fails. A revised article or data file does not update an old MP4; rerender and inspect the affected video.

Frequently asked questions

Can these models create a complete MP4?

They can help an agent build and render one when its environment provides execution tools, assets and a renderer. Their base responses are text or code. Check that an actual video file was produced and reviewed.

Which model should a beginner start with?

Try Sol 6.1 or Opus 5.5 with a short brief and one learning outcome. Choose a visual editor if that is easier to manage. Try Astra or Fable for a specific unresolved problem.

Can I do this without coding?

Yes. Use the model for research organization, script, storyboard and asset directions, then assemble the video in an editor. A coding agent can also write the project, but it still needs a way to run and render it.

Do I need an expensive GPU?

Hosted model access and rendering hardware are separate. Test a small scene in your intended environment and measure the render time before choosing hardware for a larger project.

Should every scene use generated video?

Use generated footage when it serves the lesson. Exact diagrams and labels benefit from controlled graphics; product tutorials need real captures. A combination often makes revisions easier.

Can I create different languages and aspect ratios?

Yes, with a structured project. Adapt the meaning, remeasure narration and redesign layouts for different text lengths and screen shapes. Have a fluent reviewer check important translations.

How do I know the explainer works?

Check facts and output quality, then test the learning outcome with a viewer. For a product tutorial, see whether they can complete the task. Views alone do not establish understanding.

Sources and revision notes

Official provider documentation supports the specifications, access details and prices. Model assignments, production techniques, prompts and example budgets are Kingy AI editorial guidance. The RAG example is an original storyboard, not a rendered demonstration or measured model comparison.

November 13, 2026: Added Claude Fable 5.2, released November 9, as the current Fable model while retaining Fable 5.1 as a legacy reference. Updated its exact API ID, limits, modalities, availability, retention and migration requirements; lowered the listed input, output and cache prices by 20%; and recomputed both worked budgets. Added current Fast-mode and paid-plan access details, including the dated launch promotion. Rechecked Astra, Sol 6.1, Opus 5.5, OpenAI subscription/API-credit terms, and Remotion, ElevenLabs and Runway examples; their listed base figures remain unchanged. Production roles are editorial recommendations, not hands-on benchmarks.

November 6, 2026: Rechecked the four focus models, Standard and speed-tier token prices, consumer access, and current Remotion, ElevenLabs and Runway terms; their previously listed base prices remain unchanged. Added GPT-6.1 Terra as a supporting visual-review and computer-use model with its exact ID, limits, modalities, rates and worked costs. Updated subscription/API-credit guidance for OpenAI and Claude, including Claude Ultra. Added GPT Image 2.6’s SVG, markup-editing and animated-GIF workflow, plus Claude cost analytics and short-lived message threads for production operations. These roles are editorial recommendations, not hands-on model benchmarks.

October 23, 2026: Rechecked the four main model pages and catalogs, Standard and speed-tier token prices, consumer plan access, and current Remotion, ElevenLabs and Runway terms. Main model rates, subscription prices and the existing uncached worked budgets remain unchanged. Added OpenAI’s October 20 twelve-hour prompt-cache option and its Standard and Ultrafast write rates; added a GPT Image 2.5 asset workflow with official model IDs and token rates; and added a guarded migration workflow for Anthropic API version 2026-10-21. No hands-on model benchmark or vendor success-rate claim is implied.

October 16, 2026: Rechecked the four main model pages, release catalogs, token and speed-tier prices, subscription pricing, and supporting Remotion, ElevenLabs and Runway costs. Main token rates and existing worked budgets remain unchanged. Updated Opus 5.5 Fast’s status, platform availability, configuration and cache caveat; clarified OpenAI subscription speed multipliers and old Codex model selections; added Claude Max/Team API-credit eligibility and limits, plus a tracing-based production diagnostic workflow. No new four-model video benchmark is claimed. Technique links not discussed in this revision retain their earlier review dates.

October 9, 2026: Rechecked the four main models’ specifications and Standard API prices, OpenAI and Claude subscription pages, and Remotion, ElevenLabs and Runway pricing. Main token rates and the existing worked budgets are unchanged. Added Sol/Astra Ultrafast configuration, pricing and calculated costs; clarified subscription access and Opus Fast pricing; added Haiku 5.5 supporting-task routing and a bounded Fable advisor workflow. Production roles remain editorial recommendations, not hands-on benchmark results. Setup, rendering and other technique links retain their original review date unless noted.

October 2, 2026: Researched edition revised with a clearer starting workflow, shorter explanations, corrected setup steps, updated specification detail and improved desktop and mobile layout. Prices were checked on this date; account-specific terms and taxes may differ.