Agent skill

API Timelines

by nodetool-ai in nodetool-ai/nodetool

Call nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact…

AGPL-3.0Auto-check passedMedia & Creative

Install API Timelines

skills CLI
$ npx skills add nodetool-ai/nodetool --skill api-timelines -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install nodetool-ai/nodetool api-timelines --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/nodetool-ai/nodetool.git skills-src && mkdir -p .claude/skills && cp -r skills-src/packages/system-skills/api-timelines .claude/skills/api-timelines && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
api-timelines
GitHub stars
560
Token cost
~2.6k tokens
SKILL.md length
1,362 words
Files
1
Skills in repo
127
Repo updated
First seen
Licence
AGPL-3.0

At a glance

Call nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact…

  • Works in 3 steps: In code, for motion graphics. Import… → setDocument, for a whole document you… → edit(id, ops), for targeted changes.…
  • Media & Creative work in your project
  • SKILL.md covers Calls, Coordinates and units, Three ways to build and The loop: validate, look, fix, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

API Timelines is an agent skill from nodetool-ai/nodetool. Call nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact sheets, compare versions, render the cut, manage versions and insert reusable compositions. Load before the first call into nodetool.timelines.

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Media & Creative. The repository describes itself as: Agent-first Creative Workspace. The licence is AGPL-3.0.

When your agent uses it

  • Media & Creative work in your project

Example prompts

  • “/api-timelines”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. In code, for motion graphics. Import @nodetool-ai/sandbox-timeline
  2. setDocument, for a whole document you already hold. It replaces the
  3. edit(id, ops), for targeted changes. Start with {op: "get_state"} to

What it can do on your machine

Read from SKILL.md and the folder at commit 58765d3. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are javascript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

API Timelines loads about 2.6k tokens when it runs. Until then it costs about 88 tokens; SKILL.md has 1,362 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~88
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from nodetool-ai/nodetool at commit 58765d3, republished under its AGPL-3.0 licence (© nodetool-ai). 1,362 words, ~2,649 tokens.

Download SKILL.mdSave it as .claude/skills/api-timelines/SKILL.md (or your agent's skills folder).
name
api-timelines
description
Call nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact sheets, compare versions, render the cut, manage versions and insert reusable compositions. Load before the first call into nodetool.timelines.

nodetool.timelines

A timeline is a sequence: tracks of clips — media, text, shapes, groups, 3D models and MIDI — with animations, transitions, masks, mattes, effects and markers. This skill is the call reference and the build loop. The op contract, the animation roles and the preset catalog are motion-graphics. The craft is in motion-direction, motion-principles, motion-curves, frame-composition, color-motion and beat-sync-editing.

Calls

CallDoesAnswers
list({query, limit})Lists sequences, newest first.{timelines}
create(name, {fps, width, height, project_id})Creates an empty sequence. The defaults are 30 fps and 1920×1080. Vertical is 1080×1920.{timeline_id, …}
get(id)Reads the stored document: fps, size, duration, tracks, clips, markers.The document with its metadata
edit(id, ops)Applies up to 60 ops in order and saves.{applied, failed, ops, tracks, clips}. Each entry of ops has its own ok.
setDocument(id, document, {fps, width, height, expected_updated_at, snapshot_name})Writes a whole document. It is validated first and snapshotted before the write.The validation of what landed
validate(idOrDocument, {tier, normalize, fps, width, height})Checks the structure without a render.{ok, errors, warnings, summary}
preview(idOrDocument, opts)Composites real frames.Frames with image handles and layer reports, or one contact sheet
compare(a, b, {times_ms, range, width})Differences the pixels of two sides — each an id, {timeline_id, version} or a document; never a shipped-example slug.A difference from 0 to 1 per frame, and a side-by-side sheet
render(id, opts)Renders the cut to a video file as a job.{job_id}, or the asset with wait: true
versions(id, {save_type, limit}), getVersion(id, n)Lists and reads snapshots.Version rows, newest first
snapshot(id, {name}) (also createVersion)Saves a manual version. Manual versions are never pruned.The version number
restore(id, n)Rolls back. The state it replaces is snapshotted first, and the result is validated.The findings
deleteVersion(id, n)Deletes one snapshot. This cannot be undone.—
examples.list({query})Lists the shipped example timelines.Slugs, stats, poster and video locators
examples.get(slug, {scene_id, clip_offset, clip_limit})Reads one example scene.Metadata, a scene catalog and a bounded excerpt
examples.source(slug)Reads the builder script that made an example.Full JavaScript, imports included
compositions.list({source, query, limit}), compositions.get(id)Lists and reads templates: title card, lower third, caption bar, callout, CTA end card, logo sting, and the user's own.Rows with their parameters
compositions.save(timelineId, groupTarget, name, params, {description})Saves a group as a template.The composition id
compositions.remove(id)Deletes a saved template.—
code.get(id)Reads the timeline's authoring code, when it has any.{code, baked_at, scenes: [{name, group_id, edited}]} — code is null for a timeline with none
code.set(id, code, {force, require_match})Bakes code and merges it into the document, scene by scene: an untouched scene is replaced, a hand-edited one is kept and reported in conflicts unless force overwrites it (true for every scene, or an array of names). The bake runs no capability, so code must build the timeline from values alone. require_match: true attaches the code only if it bakes to exactly the saved document, which is what v.save() does.{timeline_id, errors, warnings, conflicts, scenes}, plus embedded with require_match
code.edit(id, edits, {force})Exact-match string replacements against the stored code (each old must match exactly once), then bakes and merges the same way as set. The small-diff path for one change.Same as set
code.rebake(id, {force})Reruns the stored code unchanged and merges again — for picking up a shipped example's own current script, or re-applying force to a scene left conflicted.Same as set
code.detach(id, scenes)Stops tracking scenes (scenes is "all" or an array of names) — a later rebake never touches them again.{timeline_id, scenes}
Changing a code-backed timeline

For any timeline that already has code (code.get(id).code is not null), the path is: code.get(id) → code.edit(id, edits) with a few small exact replacements → read the conflicts/warnings it answers → preview(id, {sheet: true}) and look. edit_timeline ops still apply, for a timeline with no code and for a fine hand tweak on a code-backed one — but a hand edit inside a scene the code tracks makes that scene "edited": the next code.set/code.edit/code.rebake reports it in conflicts and keeps the hand-edited version rather than silently overwriting it. Pass force (true, or the scene's name in an array) to overwrite it with the code's own version instead of keeping the edit. A new timeline: build it and call save() — it attaches the retained program, the scene code with every research or generation result as a literal, so the timeline is already code-backed and a rebake repeats no call. Read saved.code.warnings when embedded is false. Otherwise, or to attach code after the fact, create, then code.set.

Coordinates and units

  • transform.position.x/y is in sequence pixels from the frame centre. Positive x moves right and positive y moves down. This holds for every clip, text and shapes included.
  • Shape geometry shape.x/y/width/height is in 0..1 fractions of the frame from the top-left. It is not the transform position.
  • Masks use the 0..1 space of the clip itself.
  • Track order is z-order: index 0 draws on top. add_track appends to the bottom, so add the overlays last or fix the order with move_track.
  • Times are in milliseconds. Custom-curve keyframes use t from 0 to 1 over the window of the animation.
Show full SKILL.md (518 more words)Show less

Three ways to build

  1. In code, for motion graphics. Import @nodetool-ai/sandbox-timeline: scenes of shapes, text and images, keyframed in frames, and saved with saveTimeline in one call. Read nodetool.packs.docs("@nodetool-ai/sandbox-timeline") first. This is the path for a dense, layered piece.
  2. setDocument, for a whole document you already hold. It replaces the stored document field for field, so read get(id) and send it back changed. Missing bookkeeping is filled in: track index, visible, locked; clip sourceType, status, locked, versions; animation and effect ids; markers. Pass expected_updated_at to refuse the write when someone changed the timeline after you read it.
  3. edit(id, ops), for targeted changes. Start with {op: "get_state"} to read the ids. Check failed and the ok of each entry in ops before a dependent edit. A batch can save its good ops even when a later one fails.
js
await nodetool.timelines.edit(id, [
  { op: "add_track", type: "audio", name: "Music" },
  { op: "add_text_clip", text: "Hi", startMs: 0, durationMs: 2000 },
  { op: "animate_clip", target: "Hi", animations: [{ role: "in", preset: "fade" }] },
  { op: "set_effects", target: "Hi", effects: [{ type: "blur", radius: 8 }] }
]);

Existing media goes on with {op: "add_media_clip", asset: "asset://<id>.mp4"}, which appends after the last clip on the track. One call for each asset lays them end to end. set_effects replaces the whole chain, and an unknown effect parameter is refused.

The loop: validate, look, fix

  1. Study an example before a showcase piece. examples.list(), then examples.get(slug) for the scene catalog, then examples.get(slug, {scene_id}) for one scene. Page long scenes with clip_offset: next_clip_offset until truncated is false. Return only the fields you study; the excerpts are large.
  2. Validate. validate(id, {tier: "showcase"}) adds warnings about the count of scene groups, custom animations per visible second, effect variety, clip density, fast motion without blur, the finish, camera depth and concurrent layers. Each warning names an example. Warnings do not change ok. For an inline document, pass normalize: true to fill in the bookkeeping as setDocument does.
  3. Look. Validation cannot judge the picture. Preview real frames:
    • times_ms (up to 8) or count (default 3) for single frames.
    • range: {from_ms, to_ms, count} (up to 24) to sweep a move, with sheet: true for one labelled contact sheet.
    • width (default 640, max 1280) and motion_blur_samples with shutter_angle.
    • The sheet comes back as sheet.image. Pass its asset_id to view_image. Without a sheet, each frame has its own image.
    • Sample the middle of an animation, not its ends.
    • A frame's degraded list names where the preview draws differently from the export, and effects_not_applied names effects it cannot draw.
  4. Fix and compare. After a change nobody asked for, run compare({timeline_id: id, version: n}, id) to prove which frames it touched. A difference of 0 everywhere means the edit was cosmetic.
  5. Render before you call the cut done. render(id, {preview_scale: 0.5}) is a fast draft. wait: true blocks up to timeout_ms (default 180000, clamped to 300000). On a timeout the job keeps going; wait on it with nodetool.jobs.wait(job_id).

Render options

format is mp4 (default), webm, mov or png_sequence. Only webm, mov and png_sequence carry alpha. Also video_codec, bitrate (a number or "8M"), motion_blur_samples with shutter_angle, include_audio (default true) and preview_scale.

Documents from other surfaces

A storyboard or a script assembles into a timeline of its own media (nodetool.storyboards.assembleTimeline, nodetool.scripts.assembleTimeline). For anything else, create your own timeline instead of editing one the user has open.

© nodetool-ai, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in packages/system-skills/api-timelines of nodetool-ai/nodetool.

Open the folder on GitHubat commit 58765d3

Compare with similar skills

API Timelines next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

API Timelines compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
API Timelines this skillnodetool-ai/nodetool560—~2.6kAutomated safety check: PassAGPL-3.0
Guizang Social Cardsop7418/guizang-social-card-skill7.4k1 repos~7.8kAutomated safety check: PassAGPL-3.0
Weekly Changelog Videoheygen-com/hyperframes59k—~3.3kAutomated safety check: PassApache-2.0
Anthropic Brand Stylinganthropics/skills180k30 repos~559Automated safety check: PassApache-2.0
MoneyPrinterTurbo Video Generatorharry0703/MoneyPrinterTurbo129k—~2.1kAutomated safety check: WarnMIT
Brag Slim Launch Video Makerlatent-spaces/brag14k1 repos~1.9kAutomated safety check: PassMIT

Similar skills

  • Guizang Social Cards

    op7418/guizang-social-card-skill

    Produces social card sets for Xiaohongshu and WeChat: carousels, Live Photo motion cards and puzzle layouts, and WeChat cover pairs, rendered from single-file HTML.

    7.4k GitHub starsUsed in 1 repo~7.8k tokens
    Media & CreativeAuto-check passed
  • Weekly Changelog Video

    heygen-com/hyperframes

    Turns a weekly changelog markdown file into a branded HyperFrames video with voiceover, animated mock-UI scenes and captions, using fonts, background and scripts bundled in the skill.

    59k GitHub stars~3.3k tokensUpdated today
    Media & CreativeAuto-check passed
  • Anthropic Brand Styling

    anthropics/skills

    Official

    Applies Anthropic's brand colors and fonts to artifacts such as PowerPoint slides, using fixed hex values for text and accents, Poppins headings and Lora body text.

    180k GitHub starsUsed in 30 repos~559 tokens
    Media & CreativeAuto-check passed
  • MoneyPrinterTurbo Video Generator

    harry0703/MoneyPrinterTurbo

    Installs and runs MoneyPrinterTurbo to turn a topic or script into a finished short video with voice-over, subtitles, stock footage and music.

    129k GitHub stars~2.1k tokensUpdated today
    Media & CreativeAuto-check: warnings
  • Builds a short, shareable launch video with music and motion from a project directory or a website URL, using only tools already on the machine.

    14k GitHub starsUsed in 1 repo~1.9k tokens
    Media & CreativeAuto-check passed
  • HyperFrames Media Use

    heygen-com/hyperframes

    Finds, generates and edits media for HyperFrames video projects: music, sound effects, images, icons, logos, voiceovers, captions and color grades.

    59k GitHub stars~2.4k tokensUpdated today
    Media & CreativeAuto-check passed

More from nodetool-ai/nodetool

All 127 skills in this repo
  • Beat Sync Editing

    nodetool-ai/nodetool

    Cut a NodeTool timeline to music and shape its pacing — detect the beat grid, place cuts on phrases, pick a cut type, build speed ramps with time remap, and give the piece an arc.

    560 GitHub stars~2.6k tokensUpdated today
    Auto-check passed
  • Caption Titles

    nodetool-ai/nodetool

    Add and animate a consistent text layer on an existing NodeTool timeline.

    560 GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • Color Motion

    nodetool-ai/nodetool

    Choose and animate colour on a NodeTool timeline, including shape and text gradients, colour grades, 3D LUTs, and dither.

    560 GitHub stars~2.3k tokensUpdated today
    Auto-check passed
  • Commercial Beat Sheet

    nodetool-ai/nodetool

    Write a shootable, precisely timed commercial beat sheet and store it as a NodeTool storyboard, with a consistent entity roster behind every shot.

    560 GitHub stars~4.6k tokensUpdated today
    Auto-check passed
  • Elevenlabs Audio Prompting

    nodetool-ai/nodetool

    Direct ElevenLabs speech, dialogue, sound effects and music — the bracketed audio tags v3 acts on and why the voice decides whether a tag lands, stability as the delivery dial, punctuation instead…

    560 GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • Frame Composition

    nodetool-ai/nodetool

    Stage the frame on a NodeTool timeline — grids, focal placement, safe areas per aspect ratio, depth layers and parallax, camera moves, and where elements enter and leave.

    560 GitHub stars~3.5k tokensUpdated today
    Auto-check passed

Questions about API Timelines

What does API Timelines do?

Call nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact…. API Timelines is an agent skill from nodetool-ai/nodetool.timelines from a code action: create, read, edit or write a whole timeline, study the shipped example timelines, validate at the showcase tier, preview composited frames and contact sheets, compare versions, render the cut, manage versions and insert reusable compositions.

When should I use API Timelines?

API Timelines fits situations like: media & Creative work in your project.

How do I install API Timelines in Claude Code?

Run `npx skills add nodetool-ai/nodetool --skill api-timelines -a claude-code`. Or copy the skill folder (packages/system-skills/api-timelines in nodetool-ai/nodetool) into .claude/skills/api-timelines in your project. Claude Code loads it when a task matches its description.

How do I install API Timelines in Codex?

Run `npx skills add nodetool-ai/nodetool --skill api-timelines -a codex`. Or copy the skill folder (packages/system-skills/api-timelines in nodetool-ai/nodetool) into .agents/skills/api-timelines in your project. Codex loads it when a task matches its description.

Can I use API Timelines in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add nodetool-ai/nodetool --skill api-timelines -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/api-timelines, .gemini/skills/api-timelines, .github/skills/api-timelines and .opencode/skills/api-timelines in your project.

What does API Timelines need to run?

SKILL.md names no scripts, command-line tools or credentials: API Timelines is instructions for the agent only.

Does API Timelines access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is API Timelines safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does API Timelines use?

API Timelines is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does API Timelines use?

About 2.6k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to API Timelines?

Skills that share tags, products or a category with API Timelines: Guizang Social Cards (op7418/guizang-social-card-skill, 7.4k stars), Weekly Changelog Video (heygen-com/hyperframes, 59k stars), Anthropic Brand Styling (anthropics/skills, 180k stars) and MoneyPrinterTurbo Video Generator (harry0703/MoneyPrinterTurbo, 129k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains API Timelines?

nodetool-ai (a GitHub organization) maintains it in nodetool-ai/nodetool, which has 560 GitHub stars. The repository holds 127 skills in this directory. The repository was last updated on October 9, 2026.

Source: nodetool-ai/nodetool on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.