In Active Development • Pre-release Preview

Let your GPU code for you overnight.

An asynchronous developer queue and multi-agent orchestrator built specifically for local LLMs. Eliminates GPU idle stalls by automatically checkpointing Git state and context-switching tasks when human input is requested.

📦 Public downloads and NuGet binaries are currently in preparation. You can build from source today.
nightcodeforge-worker: hangfire-inference-1
WorkerCount = 1 • VRAM Safe
🗂️ Task Backlog & Status DAG Active
#TASK-104 Stage 2: Implementation
Add Container ICU dynamic timeouts
Branch: feature/task-104 • Crucible Agent
#TASK-103 Awaiting Human Input
Refactor Auth token storage schema
Context Checkpointed (WIP commit saved)
#TASK-105 Queued (Priority: Standard)
Live Operations Telemetry Refinement
Depends on: #TASK-104
⚡ Real-time Context Switch Stream SignalR Stream
02:14:10 [Agent] Prompting developer: "Should refresh tokens be single-use?"
02:14:11 [Git] Checkpoint: git commit -m "WIP: Task 103" --no-verify
02:14:11 [Worker] Saved agent state to DB. Freeing GPU worker immediately.
02:14:12 [Queue] Dequeued Task 104 → Checked out feature/task-104
02:14:13 [OllamaRouter] Target: Dedicated LAN GPU • Model: qwen2.5-coder:32b
02:14:18 [Crucible] Executing: dotnet test --filter "Category!=Acceptance"
The Core Problem & Breakthrough

Zero Idle GPU Time. Continuous Engineering.

When running local models, hardware is strictly bounded by VRAM. Conventional coding agents freeze when asking questions, wasting hours of compute.

Conventional Agent Tools

GPU Contention & Idle Blocks

Local LLM inference requires dedicated VRAM. Running multiple agents concurrently causes VRAM thrashing and Out-Of-Memory (OOM) crashes.

× Agent encounters an ambiguity and waits for a developer response.
× The background process blocks and retains GPU allocation all night.
× Remaining backlog tasks are completely stalled, wasting valuable compute.
The NightCodeForge Approach

Non-Blocking Git Checkpointing

NightCodeForge decouples tasks from the GPU worker through native Git branching, instant WIP state commits, and priority rescheduling.

✓ On question trigger, agent memory is serialized and uncommitted files saved via Git WIP.
✓ Worker terminates immediately, freeing the GPU for the next backlog task.
✓ When the developer replies, the task returns with llm-urgent priority.
Engineered For Quality

Architectural Highlights

Designed from the ground up as a production-grade developer platform combining determinism with local LLM capabilities.

🛡️

Strict VRAM Protection

A dedicated Hangfire inference queue enforces WorkerCount = 1 across tasks, guaranteeing zero VRAM thrashing or OOM crashes on consumer and workstation GPUs.

Sequential Hardware Bounds
🔀

Native Git CLI Isolation

Direct execution via CliWrap on isolated feature/task-{id} branches. Zero reliance on brittle wrappers, with deterministic branch resets and squash merges.

Pure Git Subsystem
🧩

3-Agent Workflow Pipeline

Stage 1 reviews and prompts humans proactively before coding begins; Stage 2 handles implementation, test execution and repair; Stage 3 inspects live git diffs and fixes regressions.

Review → Code → Audit
🔌

Universal Agent Harnesses

Run in-process native C# agents via Crucible, run external agents via Pi JSON-RPC, or connect open coding agents via the Agent Client Protocol (ACP).

Crucible • Pi • ACP
🌐

Dual-Compute with OllamaRouter

Route 95% of heavy backlog jobs to a dedicated high-VRAM LAN server while keeping your workstation GPU 100% responsive for real-time interactive ideation chat.

Local Host + LAN Server
🚀

Deterministic CLI Onboarding

The ncf CLI tool prepares repositories in seconds: merges gitignore, applies editorconfig, installs agent skills, and runs a 5-pillar project readiness audit.

ncf init & ncf audit
Deep Architecture

Under The Hood

Explore the components powering NightCodeForge's autonomous workflow execution.

Stage 1

ForgeTask Review Agent

Pre-inspects the codebase, clarifies ambiguities, and asks the human developer clarifying questions upfront before touching any code.

System Prompt: Clarity & Alignment
Stage 2

Implementation Agent

Receives the approved technical specification and developer answers, modifies code, runs compiler/build loops, executes tests, and iterates to green.

System Prompt: TDD & Coding
Stage 3

Code Review & Fixes

Generates a live git diff against the base branch, evaluates against rigorous quality checklists, and applies corrective patches.

System Prompt: Security & Diff Audit

100% Private, On-Premise Dual-Compute Architecture

Running local models doesn't mean your workstation has to grind to a halt. NightCodeForge integrates first-class with OllamaRouter to dynamically partition workloads:

  • •
    Host GPU (Workstation): Powers real-time Ideation Chat and developer codebase exploration concurrently without waiting for the background queue.
  • •
    Dedicated LAN GPU Server: Runs heavy, multi-turn coding and test-execution tasks with high-context models (e.g. Qwen 2.5 Coder 32B or DeepSeek R1).
  • •
    Optional Cloud Overflow: Allows zero-VRAM offline AI diagnostics and quick transcript audits when local compute is busy.
BACKEND & ENGINE
.NET 10 / C#
High performance, strict typing, cross-platform.
UI & TELEMETRY
Blazor & SignalR
Low-latency live streaming & interactive dashboard.
QUEUE SYSTEM
Hangfire + SQLite
Single-worker priority queues (urgent vs standard).
AI INTEGRATION
Microsoft.Extensions.AI
Ollama, OpenAI-compatible, & OllamaRouter.
Project Status

Current State & Availability

NightCodeForge is currently in active pre-release development. Here is exactly where the project stands today.

🚧

Pre-Release Phase — Not Yet Available for Public Download

NightCodeForge is advancing rapidly through core architectural phases. Pre-compiled binaries, packaged desktop installers, and public NuGet packages are currently in development and will be released once initial integration phases conclude. In the meantime, full source code is public and can be tested from GitHub.

✅

Core Orchestrator & Engine

Single-worker Hangfire queue, task DAG dependencies, and EF Core persistence.

✅

Native Git Context Switching

CliWrap branch sandboxing, automatic WIP checkpointing, and safe diff handling.

✅

Interactive Web UI & SignalR

Blazor Server dashboard, live terminal stream, question inbox, and review room.

✅

Universal Harnesses & CLI Tool

Crucible C# harness, ACP protocol support, and the ncf preparation tool.

🔄

Phase 11: Container & Hardening (Current)

Dynamic tool timeouts, containerized ICU support, command transparency, and test expansion.

⏳

Public Distribution & Installers (Next)

Packaged standalone server binaries, NuGet global tools, and official download bundles.

Interested in testing the code? Build from source
Requires .NET 10 SDK & Git
# Clone the repository
git clone https://github.com/jetelain/NightCodeForge.git
cd NightCodeForge

# Build the solution (.NET 10)
dotnet build

# Run tests
dotnet test --filter "Category!=Acceptance&Category!=E2E"