How GenKaKu works
The flow
User → Orchestrator → Worker → tokens stream back → User
- You send a message from the genkaku.app chat interface
- The orchestrator receives your request and finds a worker that serves the model it needs
- The worker runs inference on their GPU and streams tokens back through the orchestrator
- You see the response appear in real-time, word by word
The orchestrator
The orchestrator is a Node.js server using Socket.io for real-time communication. It handles:
- Authentication — verifying users and workers via Privy
- Job queue — managing incoming requests and matching them to available workers
- Worker registry — tracking which workers are online, their capabilities, and current load
- Routing — directing jobs to the right worker type for the requested model
- Worker selection — picking which idle worker gets the job (weighted-random by measured tokens/sec)
- Tool calls — running web searches when a model requests one, and feeding the results back
- Stats — broadcasting real-time network statistics every 5 seconds
The orchestrator does not store conversations. It routes traffic and moves on.
Browser workers
Browser workers run LLMs directly in your browser tab using WebGPU through the WebLLM library. No installation required — just open the page and click start.
Browser workers run Qwen3.5 Uncensored and serve the browser lane — genkaku-pro API requests and free prompts. The tab picks the size its GPU can hold when you start it: 9B (~5.1GB download, ~6.4GB VRAM) or 4B (~2.4GB download, ~4GB VRAM). Both are uncensored.
The model downloads once and caches in the browser. Subsequent starts are instant.
Native workers
Native workers run on your machine using ollama, which supports CUDA (NVIDIA), Metal (Apple Silicon), and Vulkan (AMD/Intel) acceleration.
Native workers run Qwen3.8 27B Uncensored — the network's one text model — and serve every chat message and every qwen3.8-27b-uncensored API request. There is no model to choose: every native worker runs the same build. They require a 16GB+ NVIDIA GPU (24GB recommended), a 24GB+ AMD card, or a 32GB+ Apple Silicon Mac, and deliver 25+ tokens per second depending on hardware.
Image workers
Image workers are a third worker type: independent GPUs running ComfyUI for image generation. It's exposed both as the generate_image tool the text model can call when you ask for a picture, and as the image API — either way an image worker renders the result.
Job routing
| Lane | Worker type | Model |
|---|---|---|
Chat + qwen3.8-27b-uncensored | Native (ollama) | Qwen3.8 27B Uncensored |
genkaku-pro + free prompts | Browser (WebGPU) | Qwen3.5 Uncensored, 9B or 4B |
| Image generation | ComfyUI | Chroma1-HD |
Worker selection
When a job is ready, the orchestrator looks at the idle workers that serve the requested model and picks one by weighted-random choice. Each worker's weight is its measured average tokens/sec (with a floor so the slowest workers still get some traffic). Faster workers get more jobs, but work and earnings spread across the whole pool instead of always landing on the single fastest worker.
Web search
Web search is model-driven. The model itself decides whether to call the web_search tool. When it does, the orchestrator runs the search (Brave Search API), feeds the results back to the model as a tool result, and the model continues from there — a round trip, not a pre-fetch. The model then responds with information grounded in real, up-to-date web content and cites its sources.
Token streaming
Responses stream in real-time. As the worker generates each token, it's sent through the orchestrator to the user immediately. There's no waiting for the full response — you see it being written live, just like any other chat AI, except the compute is happening on someone's GPU across the network.