Chalkline

from complex logic into clear 2D explainer videos

Comment

Inspiration

I’ve always been captivated by the clarity of creators like 3Blue1Brown, who turn impenetrable equations into intuitive visual stories. However, creating high-quality mathematical animations with Manim is notoriously difficult, requiring both deep subject-matter expertise and precise coding skills. I wanted to build a tool that makes this "explainer" magic accessible to everyone.

Chalkline was born from a simple question: Can a multi-agent system think from first principles and then "draw" its reasoning in real-time?

What it does

Chalkline is an AI-powered "explainer engine" that transforms complex technical topics into clear, 2D animations. it performs a deep logical breakdown of a subject to ensure the final output is educationally sound and visually intuitive.

How we built it

Chalkline is built on a Hierarchical Multi-Agent Architecture powered by Gemini 3 . The Orchestrator: Acts as the "Director," managing the flow between specialized workers.

The Tutor Agent: This is the "Brain." It breaks down users request from First Principles. For example, when asked about the Pythagorean theorem, it doesn't just provide a formula; it reasons about the areas of squares: $$a^2 + b^2 = c^2$$.

The Manim Coder: A specialized agent that converts the Tutors's logic into modular Python code.

The Parallel Renderer: To solve the hardware bottleneck (rendering on 16GB RAM), I implemented a "Divide and Conquer" strategy. The orchestrator splits the script into individual scenes and "fans them out" to parallel workers for rendering, before "conquering" them back into a single video via FFmpeg.

Challenges we ran into

The "Hallucination" Gap: Initially, a single agent would try to write 500 lines of Manim code at once, leading to syntax errors. I solved this by forcing the Script agent to write a "Visual Roadmap" first, which the coder then follows scene-by-scene.

Hardware Constraints: Rendering complex 2D animations is CPU-heavy. My breakthrough was moving from a sequential local render to a distributed cloud-native approach, treating Google Cloud Run as a scalable "Animation Factory."

API Handoffs: Managing function calling between agents required precise prompt engineering to ensure the "Script Writer" could successfully hand off a "Visual Plan" to the "Coder."

Accomplishments that we're proud of

I am incredibly proud of the Hierarchical Multi-Agent Orchestration. Seeing the "Tutor Agent" successfully break down a concept into first principles, and then seeing the "Coder Agent" pick up that visual roadmap and execute it, was a "wow" moment.

Getting the parallel rendering pipeline to work was another huge win. By splitting the video into independent classes and stitching them with FFmpeg, I effectively turned a 20-minute render into a 4-minute "sprint," proving that agentic workflows can overcome physical hardware limitations.

What we learned

I learned that the future of education isn't just "generative" it's agentic. It’s about AI that doesn't just tell you the answer but builds a visual world to show you why it’s true.

What's next for Chalkline

The next steps for Chalkline include:

Dynamic Feedback Loops: Implementing an "Editor Agent" that watches the rendered video, catches visual bugs, and sends "Fix-it" prompts back to the Coder Agent.

Direct PDF-to-Video: Expanding the Physicist Agent’s ability to ingest massive textbooks and automatically generate an entire "First Principles" course syllabus as a series of videos.

Built With

Share this project:

Updates