Make a video with an agent¶

This is the main way to use manimvox: a coding agent (Claude Code, Codex, Cursor, Gemini CLI and others) makes the video through manimvox's skills, or an agent you build with a Python framework calls its tools. How it works explains what the agent does.

From install to a video from Claude Code, in about two minutes: real commands and a real Claude Code run. More about this video.

Make a video with your coding agent¶

manimvox ships eleven agent skills, so your coding agent can plan, write, render and check a video for you. Install them into the agents you use:

npx skills add LaplacianAI/manimvox                      # detects your agents and lets you pick
npx skills add LaplacianAI/manimvox -g -y                # your detected agents, for all projects, no prompts
npx skills add LaplacianAI/manimvox -a claude-code -a codex -y

Without Node.js, manimvox installs the same skills itself:

manimvox skills install                  # pick agents; add --agent ID (repeatable) to name them
manimvox skills install --global --yes   # every project, no questions
manimvox skills check                    # are the installed skills current?
manimvox skills update
manimvox skills remove

Other flags: --project (the default) installs in the current project, --copy copies the skills instead of linking them, and --native skips npx even when it is present. Without a terminal, install and remove need --yes (with --agent ID to choose agents), npx or not. An npx in the current folder is ignored. Only the eleven manimvox skills are ever touched.

npx skills add LaplacianAI/manimvox fetches from GitHub, so it installs whatever is on the default branch. manimvox skills install installs the skills that match your installed manimvox version.

Agent-specific routes: - Claude Code: claude plugin marketplace add LaplacianAI/manimvox, then claude plugin install manimvox@manimvox. - Gemini CLI: gemini extensions install https://github.com/LaplacianAI/manimvox. - Codex and Cursor: the plugin manifests in the repository root (.codex-plugin/, .cursor-plugin/) point at skills/.

Then ask your agent: "make an explainer video of ".

Use it from a Python agent framework¶

An agent built on a Python framework has no shell, so manimvox also ships its commands as tools (manimvox.tools) and adapters for eight frameworks. Install the extra for yours, next to a voice:

pip install "manimvox[kokoro,agno]"
pip install "manimvox[kokoro,langchain]"
pip install "manimvox[kokoro,pydantic-ai]"
pip install "manimvox[kokoro,openai-agents]"
pip install "manimvox[kokoro,crewai]"
pip install "manimvox[kokoro,llamaindex]"
pip install "manimvox[kokoro,haystack]"
pip install "manimvox[kokoro,google-adk]"

Install one, in the environment your agent runs in. Each tool builder (manimvox_tools, ManimvoxTools, manimvox_toolset) takes the project folder, such as hash-maps, and pins the tools to it.

Agno (set AGNO_TELEMETRY=false if you do not want Agno to send usage telemetry) loads the skills itself and takes the tools as a toolkit:

import manimvox
from agno.agent import Agent
from agno.skills import LocalSkills, Skills
from manimvox.integrations.agno import ManimvoxTools

agent = Agent(
    model=...,
    skills=Skills(loaders=[LocalSkills(str(manimvox.skills_path()))]),
    tools=[ManimvoxTools("hash-maps")],
)

LangChain Deep Agents:

from deepagents import create_deep_agent
from manimvox.integrations.langchain import deep_agent_kwargs

agent = create_deep_agent(model=..., **deep_agent_kwargs("hash-maps"))

Pydantic AI:

from pydantic_ai import Agent
from manimvox.integrations.common import manimvox_instructions
from manimvox.integrations.pydantic_ai import manimvox_toolset

agent = Agent(..., toolsets=[manimvox_toolset("hash-maps")], instructions=manimvox_instructions())

OpenAI Agents SDK:

from agents import Agent
from manimvox.integrations.openai_agents import manimvox_instructions, manimvox_tools

agent = Agent(name="manimvox", instructions=manimvox_instructions(), tools=manimvox_tools("hash-maps"))

CrewAI:

import manimvox
from crewai import Agent
from manimvox.integrations.crewai import manimvox_tools

agent = Agent(..., tools=manimvox_tools("hash-maps"), skills=[manimvox.skills_path()])

LlamaIndex:

from llama_index.core.agent.workflow import FunctionAgent
from manimvox.integrations.llamaindex import manimvox_instructions, manimvox_tools

agent = FunctionAgent(tools=manimvox_tools("hash-maps"), llm=..., system_prompt=manimvox_instructions())

Haystack (set HAYSTACK_TELEMETRY_ENABLED=False if you do not want Haystack to send usage telemetry):

from haystack.components.agents import Agent
from manimvox.integrations.haystack import manimvox_skills, manimvox_tools

agent = Agent(chat_generator=..., tools=[*manimvox_tools("hash-maps"), manimvox_skills()])

Google ADK:

from google.adk.agents import LlmAgent
from manimvox.integrations.google_adk import manimvox_skill_toolset, manimvox_tools

agent = LlmAgent(..., tools=[*manimvox_tools("hash-maps"), manimvox_skill_toolset()])

Security. Each adapter pins the tools to the one project folder it was built with, so the model cannot name another folder. But an episode is Python, and render runs it with your permissions. Run an agent in a container or VM when the model or its input is untrusted.

CrewAI cannot share an environment with the OpenAI Agents SDK (they need different major versions of openai) or with the f5 voice extra (CrewAI needs rich>=14.2, F5-TTS needs rich<14). Install them separately. CrewAI also needs Python below 3.14, and sends usage telemetry unless you set CREWAI_DISABLE_TELEMETRY=true.

Other frameworks: - Frameworks that read SKILL.md folders take manimvox.skills_path(): Microsoft Agent Framework (SkillsProvider.from_paths) and AG2 (SkillsToolkit). - Any framework can register manimvox.integrations.common.json_tools(folder) and file_tools(folder) as plain functions. - pydantic-ai-harness[skills] and the OpenAI SDK's sandbox Skills are native alternatives to read_skill.

Notes: - Tell the agent which folder the project is in. project_note(folder) writes that line for the instructions. - A render takes minutes and a video takes many tool calls, so raise the framework's turn or request limit; the examples show how. - The plain functions, json_tools() and file_tools() with no folder, are unbound. Pass the folder, json_tools(folder) and file_tools(folder), whenever a model is calling them.

A runnable script for each framework is in examples/agents/.