Fogsight: an LLM animation agent you run yourself

What Fogsight does and who it is aimed at

Fogsight is described in its README as an animation engine agent driven by a large language model. The workflow it presents is deliberately narrow: you type an abstract concept or a word, and the system produces an animation with bilingual narration and what the README calls cinematic visual quality. The repository's own examples use inputs such as 熵增定律 (the law of increasing entropy), 欧拉定理 (Euler's theorem), 冒泡排序 (bubble sort), and "affordance in design".

The audience is therefore not a motion-design studio. It is a person who has a concept and wants to see it animated without building a timeline by hand. The README describes the interface as a Language User Interface, meaning the refinement loop is conversational: you talk to the model about the animation rather than dragging keyframes. That is the actual product claim, and it is worth separating from the marketing language around it. The generation quality depends entirely on the model behind the API key you supply, not on Fogsight itself.

The project is a member of the WaytoAGI open source programme, and the contributor list mixes university researchers, community members, and independent developers and AI artists. That mix shows up in the documentation, which is written in Chinese first with an English readme alongside it.

The pipeline: LLM orchestration, FastAPI backend, browser front end

The repository layout is small and readable. There is app.py, a start_fogsight.py launcher, a static/ directory, a templates/ directory, and a requirements.txt that lists fastapi, uvicorn, pydantic, openai, jinja2, pytz, google-genai, and requests. There is no separate agent framework in the dependency list, so the orchestration is the project's own code sitting on top of an OpenAI-compatible client plus a Google Gemini client.

The flow implied by those files is: the browser page served from templates/ collects a topic, the FastAPI application in app.py sends the request to the configured model endpoint, and the model returns the narration and visual specification that the front end renders. Credentials live in a credentials.json file with the keys API_KEY, BASE_URL, and MODEL. The README is explicit that the SDK is OpenAI-compatible but that you should still use Gemini 2.5 Pro, while the Docker section shows an OpenRouter example pointing at anthropic/claude-sonnet-4. That inconsistency matters: the two clients in requirements.txt suggest the project can talk to more than one provider, but only Gemini is recommended in prose.

One concrete detail worth noting is pytz in the dependency list. It is the kind of package that appears when generated content carries timestamps, and it hints that the agent's internal state includes time-aware data. The README does not explain this, so treat it as an observation from the file list rather than a documented feature.

Installing Fogsight and generating a first animation

The README gives two installation paths. The Python path requires Python 3.10 or newer, a modern browser, and an API key. Start by cloning the repository and installing the dependencies:

git clone https://github.com/fogsightai/fogsight.git
cd fogsight
pip install -r requirements.txt

Next, create the credentials file from the demo template and fill in your key, base URL, and model. The README stresses that the SDK is OpenAI-compatible but that Gemini 2.5 Pro is the recommended model:

cp demo-credentials.json credentials.json

With credentials in place, the launcher script starts the backend and opens the browser at http://127.0.0.1:8000 automatically:

python start_fogsight.py

Once the page loads, type a topic such as 冒泡排序 and wait for the result. The README's own examples suggest a full generation takes long enough that waiting is part of the process, though it does not state a duration.

The Docker route is shorter if you already have Docker and docker-compose. After cloning and creating credentials.json, bring the stack up. The default port is 8000, and HOST_PORT overrides it:

docker-compose up -d
HOST_PORT=3000 docker-compose up -d

The compose file mounts credentials.json read-only into the container, sets HOST and PORT, and defines a healthcheck that requests http://localhost:8000/ every 30 seconds with a 40-second start period. The Dockerfile itself is based on python:3.9-slim, which is worth flagging: the README asks for Python 3.10 or newer, while the container image pins 3.9. If you hit an incompatibility in the Docker path, that version gap is the first thing to check. Stop the stack with docker-compose down.

Where Fogsight breaks down or is the wrong choice

The most consequential limitation is the licence. The README states the project is released under CC BY-NC-ND 4.0 and that commercial use and derivative works are prohibited, with a request to contact the maintainers for commercial environments. That is stricter than a typical open source licence. You cannot take this code, modify it, and ship it, and you cannot use it to produce commercial work under the stated terms. For a tool whose output is creative material, that restriction applies directly to what you make with it, not just to the source.

The second limitation is the model dependency. Fogsight does not ship a model. Everything depends on the API key you provide. The README recommends Gemini 2.5 Pro but the Docker example shows an OpenRouter configuration with anthropic/claude-sonnet-4, and the requirements include both openai and google-genai. The recommendation is one model, the examples show another, and the project does not document how behaviour differs between them. If your key points at a weaker model, the README offers no guidance on what degrades first.

Operationally, the credentials file is a single point of failure. The compose file mounts it read-only, and the healthcheck only confirms that the root page responds, not that the model endpoint is reachable or that generation succeeds. A container can report healthy while every generation request fails on an invalid key. There is also no documented rollback or versioning story: the repository has no releases listed, so pinning to a known-good state means pinning to a commit hash yourself.

How Fogsight differs from Manim and code-driven animation tools

The obvious comparison is Manim, the Python library used for mathematical animation. The difference is where the authoring happens. With Manim you write Python that describes scenes, objects, and transformations, and the animation is deterministic: the same script produces the same frames. Fogsight inverts that. You supply a concept in natural language, and an LLM decides the narration, the visual elements, and the motion. The output is not reproducible in the same way, because it is sampled from a model.

That trade-off cuts both ways. Manim gives you exact control and a stable result, at the cost of learning an animation API and writing the scene yourself. Fogsight removes the API learning curve but gives up determinism and hands the creative decisions to a model whose behaviour you cannot inspect from the repository. If you need a figure that renders identically every time, or you need to tweak a single element precisely, Manim is the better fit. If you want a first draft of an explainer animation from a one-word prompt, Fogsight is aimed at exactly that.

There is a second difference in deployment. Manim is a library you import. Fogsight is a service: a FastAPI backend plus a browser front end, started with python start_fogsight.py or docker-compose up. You interact with it through a page, not a function call. The README does not document a public API for programmatic generation, so treating it as a library is not supported by the material.

Maintenance, licence, and what to verify first

The repository is not archived, and the last push was on 2026-03-21. That is roughly six months before the current date, so the project is not in active development by the usual measure, and the README does not describe a release cadence. There are no releases listed, which means upgrades are pull-based: you fetch the master branch and reconcile any changes to app.py, the templates, or the credentials format yourself. Because credentials.json is mounted read-only in Docker and referenced directly in the Python path, a change to its expected keys would break both deployment routes at once, and the README does not document a migration path.

The licence deserves a second mention because it constrains upgrades as much as usage. CC BY-NC-ND 4.0 prohibits derivatives, so if you patch the code for your own workflow and want to share that patch, the licence as stated does not permit it. The README directs commercial users to contact the maintainers, which is the only route it offers. This is not legal advice; read the licence text at the link in the README and decide with whoever handles licensing in your organisation.

Before committing to Fogsight, verify three things in order. First, confirm your model provider and key work with the credentials.json format shown in the README, since the recommended model and the Docker example disagree. Second, check whether the Python 3.10 requirement in the README conflicts with the python:3.9-slim base image in the Dockerfile for your workload. Third, confirm the licence terms match how you intend to use the output, because that constraint is independent of any technical issue.

Editorial conclusion

Fogsight suits people who want to experiment with concept-to-animation generation and are willing to supply their own LLM API key, especially for non-commercial work. It is not the right tool for anyone who needs commercial rights, wants to redistribute a modified version, or expects a stable hosted API. Before adopting it, confirm which model your key actually points at, since the README recommends Gemini 2.5 but the Docker example also shows an OpenRouter configuration with anthropic/claude-sonnet-4, and read the CC BY-NC-ND 4.0 terms directly.

Frequently asked questions

Official sources

1. fogsightai/fogsight on GitHub
2. Issues
3. Project website
4. README