novanova-studio

An agent at the center of creation

NovaNova Studio is a creation workbench aimed at independent creators and visual teams. The README describes it as agent driven, meaning the AI agent is not a separate chat box but a component that runs through the whole pipeline from understanding intent to saving results. The workspace is built around an infinite canvas that holds the creative context, so images, video, prompts, and generation records stay in one place instead of being scattered across separate tools. A creator can start from a sentence in natural language or from a set of reference assets, then keep talking, generating, editing, and comparing results inside the same space. The system picks an agent profile for the image, video, or canvas scene based on context. The README frames this as removing the need to jump between many feature pages, since the agent decides which tool to call. The project also offers an online experience for users who do not want to deploy it themselves, with the homepage at novanovastudio.cn. The central idea is continuity of context: every action feeds back into the canvas, and the next action can see what came before. That loop is what separates the workbench from a collection of single purpose generators, because the agent treats the canvas as the memory of the session rather than a blank slate each time the user types a new prompt into a fresh window.

How a task moves through the system

The README lays out a five stage flow that shows how a request becomes a result. The creator supplies a goal, the system chooses an agent profile, the agent calls tools such as image generation, image editing, video generation, video editing, history query, or canvas operations, and the task is then written as a PostgreSQL snapshot and pushed to a Redis Stream consumer group. Because the long running generation is handled by a consumer reading from the stream, the current creative session is not blocked while a model works. Status, tool calls, and results are pushed back to the frontend through Server-Sent Events, so the user sees live progress, failures, or cancellations in both the conversation and the canvas. When a result lands, it is saved as a generation record that can be referenced again on the canvas or added to an asset library. The README states the canvas agent can read node state and prior tool results, which keeps the next round of edits connected to the previous context. The use of a stream consumer group is a deliberate choice: it lets generation run off the request path, so a slow video job does not freeze the interface. The SSE push then closes the loop by streaming updates back as they happen, which is what makes the experience feel live rather than poll based and gives the creator a clear view of what the agent is doing at each moment.

Built with a familiar stack

Under the hood the workbench uses a Next.js frontend, with agent orchestration handled through AgentScope and a backend task service that talks to PostgreSQL and Redis Stream. The README includes a diagram showing the creator interacting with the workbench, which calls the AgentScope agent, which in turn drives tools and the task service, and the task service writes to the database and the stream before a consumer invokes the configured AI channel adapter and returns events. This is a conventional web and message queue architecture, which should make the system approachable for teams that already run Node and Java services. The project is written in Java and published under the GPL 3.0 license. Real time feedback through SSE and persistent context through the canvas are the two ideas the README repeats as the reasons the tool feels different from a pile of disconnected generation scripts. The AI channel adapter abstraction means the model provider is configurable rather than hard coded, so a team can switch providers without rewriting the task service. The combination targets creators who iterate many times and want each iteration to remember the last, and the documented data flow makes it possible for an operator to reason about where a task sits when something goes wrong during a long generation run.

Editorial conclusion

The project is published under the GPL 3.0 license, written in Java, and demonstrated at the homepage novanovastudio.cn.