EverSpark Forge V2 — Building a Distributed AI OS

EverSpark Forge V2 is now available.

This release marks a major architectural shift for the project.

EverSpark Forge is now a Distributed AI OS where Archon acts as the control layer, while different Forge modules can run on registered nodes across different machines, GPUs, and regions.

The core idea is simple:

AI capabilities should not be tied to one machine, one GPU, or one location.

Why I rebuilt the architecture

Early versions of EverSpark Forge were much more local.

That worked well enough for proving the basic idea, but it also created an obvious limitation: every capability depended too heavily on the machine it was running on.

That becomes a problem quickly when different AI workloads have very different hardware requirements.

Image generation may need one GPU.

Audio generation may need another environment.

LLM workloads may run somewhere else entirely.

So V2 moves away from treating the machine as the center of the system.

Instead, the system is built around distributed Forge modules.

The V2 architecture

At the center of the current architecture is Archon / Orchestrator.

Archon acts as the control layer.

Remote machines run as Pods and actively register with the main system through a Tailscale-based virtual network.

Once a node is registered, Forge modules can be deployed to that node.

A deployment can look like this:

• Archon running on the main machine
• Concept Forge running on one remote node
• Image Forge running on another GPU node
• Audio Forge running on a different machine or region

The important part is that these modules no longer need to live on the same physical system.

Remote node workflow

The current V2 node workflow includes:

• Active remote node registration
• Tailscale-based networking
• Remote Forge deployment
• Node health checks
• Bandwidth testing
• Region-aware node usage

Bandwidth testing is especially useful for remote GPU nodes.

A powerful GPU is not very useful if the network connection is too slow to make the node practical.

So EverSpark Forge can test the network performance of a Pod before using it as part of the distributed system.

Concept Forge

Concept Forge handles LLM interaction and task understanding.

It is designed to support different model backends and external APIs instead of depending on one provider.

Concept Forge also forms the basis for the next stage of EverSpark Forge: higher-level task decomposition and automated Forge dispatch.

That part is still a future direction rather than something I want to claim as complete today.

Image Forge

Image Forge runs as an independent image-generation capability.

In V2, Image Forge can run on a remote node instead of being tied to the main machine.

Generated results can then be accessed directly from the remote node by the WebUI.

This avoids routing large image files back through the main control machine when that transfer is unnecessary.

Audio Forge

V2 also introduces Audio Forge.

The current implementation integrates VoxCPM2 and supports independent text-to-speech generation.

The current generation modes include:

• Image only
• Audio only
• Image + audio

Like Image Forge, Audio Forge can run remotely and expose generated results directly from its node.

What is already working

The important milestone for V2 is not just that these components exist independently.

The distributed control and deployment loop is now working end to end.

That means the system can:

• Connect remote nodes
• Register them
• Test them
• Deploy Forge modules
• Run AI workloads remotely
• Access generated results through the wider system

This is the foundation I wanted before moving further into automatic task orchestration.

What comes next

The longer-term direction is:

Natural-language request → task decomposition → task list → Forge dispatch

In other words, Archon should eventually be able to coordinate different AI capabilities automatically depending on what a task requires.

But I want to keep a clear line between what exists today and what is still being built.

V2 establishes the distributed foundation.

The higher-level orchestration layer comes next.

Demo

I recorded a V2 demo showing the current distributed workflow, including remote deployment, Image Forge, and Audio Forge.

YouTube:

https://youtu.be/yhaUHmxdNIA?si=rtGutyw_0o5Po1IS

Source code

EverSpark Forge is open source.

GitHub:

https://github.com/jhinforge/EverSpark-Forge

The demo reflects the system at the time of recording.

For the latest functionality and implementation details, the repository is the source of truth.

---

The distributed loop is now running.

I am Jhin.

And Jhin has done this.